intor 1.0.39 → 2.0.0

package/dist/config/index.cjs

@@ -1,23 +1,21 @@
 'use strict';
 
-var edge = require('logry/edge');
+// src/modules/config/constants/cache.constants.ts
+var DEFAULT_CACHE_OPTIONS = {
+  enabled: process.env.NODE_ENV === "production",
+  ttl: 60 * 60 * 1e3
+  // 1 hour
+};
 
-// src/modules/intor-config/initialize-logger.ts
-var initializeLogger = ({
-  id,
-  scope,
-  loggerOptions
-}) => {
-  const logger = edge.logry({
-    id,
-    level: loggerOptions?.level,
-    scope,
-    ...loggerOptions
-  });
-  return logger;
+// src/modules/config/resolvers/resolve-cache-options.ts
+var resolveCacheOptions = (cache) => {
+  return {
+    ...DEFAULT_CACHE_OPTIONS,
+    ...cache
+  };
 };
 
-// src/modules/intor-config/constants/cookie-options-constants.ts
+// src/modules/config/constants/cookie.constants.ts
 var DEFAULT_COOKIE_OPTIONS = {
   disabled: false,
   autoSetCookie: true,
@@ -31,7 +29,7 @@ var DEFAULT_COOKIE_OPTIONS = {
   sameSite: "lax"
 };
 
-// src/modules/intor-config/resolvers/resolve-cookie-options.ts
+// src/modules/config/resolvers/resolve-cookie-options.ts
 var resolveCookieOptions = (cookie = {}) => {
   return {
     ...DEFAULT_COOKIE_OPTIONS,
@@ -39,12 +37,8 @@ var resolveCookieOptions = (cookie = {}) => {
   };
 };
 
-// src/modules/intor-config/resolvers/resolve-fallback-locales.ts
-var resolveFallbackLocales = ({
-  config,
-  supportedLocales,
-  logger
-}) => {
+// src/modules/config/resolvers/resolve-fallback-locales.ts
+var resolveFallbackLocales = (config, supportedLocales) => {
   const { defaultLocale, fallbackLocales } = config;
   if (!fallbackLocales || typeof fallbackLocales !== "object") {
     return {};
@@ -68,7 +62,7 @@ var resolveFallbackLocales = ({
     }
   }
   for (const [locale, invalids] of invalidFallbackMap.entries()) {
-    logger.warn(
+    console.warn(
       `Invalid fallback locales for "${locale}"`,
       { invalids: [...invalids] },
       { scope: "resolveFallbackLocales" }
@@ -77,17 +71,9 @@ var resolveFallbackLocales = ({
   return validMap;
 };
 
-// src/modules/intor-config/constants/prefix-placeholder-constants.ts
-var DEFAULT_PREFIX_PLACEHOLDER = "{{locale}}";
-
-// src/modules/intor-config/resolvers/resolve-prefix-placeholder.ts
-var resolvePrefixPlaceholder = (input) => {
-  return input?.replace(/\//g, "") || DEFAULT_PREFIX_PLACEHOLDER;
-};
-
-// src/modules/intor-config/constants/routing-options-constants.ts
+// src/modules/config/constants/routing.constants.ts
 var DEFAULT_ROUTING_OPTIONS = {
-  prefix: "all",
+  prefix: "none",
   firstVisit: {
     localeSource: "browser",
     redirect: true
@@ -97,9 +83,6 @@ var DEFAULT_ROUTING_OPTIONS = {
 
 // src/shared/utils/pathname/normalize-pathname.ts
 var normalizePathname = (rawPathname, options = {}) => {
-  if (typeof rawPathname !== "string") {
-    throw new TypeError("Expected rawPathname to be a string");
-  }
   const length = rawPathname.length;
   let start = 0;
   let end = length - 1;
@@ -129,7 +112,7 @@ var normalizePathname = (rawPathname, options = {}) => {
   return result || "/";
 };
 
-// src/modules/intor-config/resolvers/resolve-routing-options.ts
+// src/modules/config/resolvers/resolve-routing-options.ts
 var resolveRoutingOptions = (routing = {}) => {
   return {
     ...DEFAULT_ROUTING_OPTIONS,
@@ -142,7 +125,7 @@ var resolveRoutingOptions = (routing = {}) => {
   };
 };
 
-// src/modules/intor-error/intor-error.ts
+// src/shared/error/intor-error.ts
 var IntorError = class extends Error {
   constructor({ message, code, id }) {
     const fullMessage = id ? `[${id}] ${message}` : message;
@@ -154,11 +137,8 @@ var IntorError = class extends Error {
   }
 };
 
-// src/modules/intor-config/validators/validate-default-locale.ts
-var validateDefaultLocale = ({
-  config,
-  supportedLocales
-}) => {
+// src/modules/config/validators/validate-default-locale.ts
+var validateDefaultLocale = (config, supportedLocales) => {
   const { id, defaultLocale } = config;
   if (!defaultLocale) {
     throw new IntorError({
@@ -167,7 +147,7 @@ var validateDefaultLocale = ({
       message: `The defaultLocale is undefined`
     });
   }
-  if (!supportedLocales?.includes(defaultLocale)) {
+  if (!supportedLocales.includes(defaultLocale)) {
     throw new IntorError({
       id,
       code: "INTOR_UNSUPPORTED_DEFAULT_LOCALE" /* UNSUPPORTED_DEFAULT_LOCALE */,
@@ -177,59 +157,44 @@ var validateDefaultLocale = ({
   return defaultLocale;
 };
 
-// src/modules/intor-config/validators/validate-supported-locales.ts
-var validateSupportedLocales = ({
-  config
-}) => {
-  const { id, loaderOptions, supportedLocales } = config;
-  if (loaderOptions && !supportedLocales) {
+// src/modules/config/validators/validate-supported-locales.ts
+var validateSupportedLocales = (config) => {
+  const { id, loader, supportedLocales } = config;
+  if (loader && !supportedLocales) {
     throw new IntorError({
       id,
       code: "INTOR_MISSING_SUPPORTED_LOCALES" /* MISSING_SUPPORTED_LOCALES */,
-      message: `"supportedLocales" is required when using loaderOptions, but it is missing.`
+      message: `"supportedLocales" is required when using loader, but it is missing.`
     });
   }
   return supportedLocales || Object.keys(config.messages || {});
 };
 
-// src/modules/intor-config/define-intor-config.ts
+// src/modules/config/define-intor-config.ts
 var defineIntorConfig = (config) => {
   const id = config.id || `ID${Math.random().toString(36).slice(2, 6)}`;
-  const logger = initializeLogger({
-    id,
-    loggerOptions: config.logger,
-    scope: "defineIntorConfig"
-  });
-  const supportedLocales = validateSupportedLocales({ config });
-  const defaultLocale = validateDefaultLocale({ config, supportedLocales });
-  const resolvedFallbackLocales = resolveFallbackLocales({
-    config,
-    supportedLocales,
-    logger
-  });
-  const resolvedCookieOptions = resolveCookieOptions(config.cookie);
-  const resolvedRoutingOptions = resolveRoutingOptions(config.routing);
-  const resolvedPrefixPlaceHolder = resolvePrefixPlaceholder(
-    config.prefixPlaceHolder
-  );
+  const supportedLocales = validateSupportedLocales(config);
+  const defaultLocale = validateDefaultLocale(config, supportedLocales);
+  const fallbackLocales = resolveFallbackLocales(config, supportedLocales);
+  const cookie = resolveCookieOptions(config.cookie);
+  const routing = resolveRoutingOptions(config.routing);
+  const cache = resolveCacheOptions(config.cache);
   return {
     id,
     messages: config.messages,
-    // Optional
-    loaderOptions: config.loaderOptions,
-    // Optional
+    loader: config.loader,
     defaultLocale,
-    // Validated
     supportedLocales,
-    // Validated
-    fallbackLocales: resolvedFallbackLocales,
+    fallbackLocales,
     translator: config.translator,
-    cookie: resolvedCookieOptions,
-    routing: resolvedRoutingOptions,
-    adapter: config.adapter || "next-client",
+    cookie,
+    routing,
     logger: config.logger,
-    prefixPlaceHolder: resolvedPrefixPlaceHolder
+    cache
   };
 };
 
+exports.DEFAULT_CACHE_OPTIONS = DEFAULT_CACHE_OPTIONS;
+exports.DEFAULT_COOKIE_OPTIONS = DEFAULT_COOKIE_OPTIONS;
+exports.DEFAULT_ROUTING_OPTIONS = DEFAULT_ROUTING_OPTIONS;
 exports.defineIntorConfig = defineIntorConfig;

package/dist/config/index.d.cts

@@ -1,30 +1,51 @@
 import { Level, NormalizerConfig, FormatterConfig, LoggerPreset } from 'logry/edge';
 import { Locale, LocaleNamespaceMessages, FallbackLocalesMap } from 'intor-translator';
 
-type InitCookieOptions = {
+type CookieRawOptions = {
+    /** Completely disable cookie usage (no read, no write, no lookup by name) - default: false */
     disabled?: boolean;
+    /** Allow the system to automatically set cookies - default: true */
     autoSetCookie?: boolean;
+    /** default: "intor.i18n.locale" */
     name?: string;
-    maxAge?: number;
-    path?: string;
+    /** default: null */
     domain?: string | null;
-    secure?: boolean;
+    /** default: "/" */
+    path?: string;
+    /** default: 60 * 60 * 24 * 365 (365 days) */
+    maxAge?: number;
+    /** default: false */
     httpOnly?: boolean;
+    /** default: process.env.NODE_ENV !== "development" */
+    secure?: boolean;
+    /** default: lax */
     sameSite?: "lax" | "strict" | "none";
 };
-type ResolvedCookieOptions = Required<Omit<InitCookieOptions, "domain">> & {
+type CookieResolvedOptions = Required<Omit<CookieRawOptions, "domain">> & {
     domain: string | null;
 };
 
-declare const intorAdapters: readonly ["next-client", "next-server"];
-type IntorAdapter = (typeof intorAdapters)[number];
-
+/**
+ * ```ts
+ * {
+ *  default: ["ui", "meta"],
+ *  "/auth": ["auth", "admin"],
+ * }
+ * // When pathname is "/" => namespaces: ["ui", "meta"]
+ * // When pathname is "/auth" => namespaces: ["ui", "meta", "auth", "admin"]
+ * ```
+ */
 type RouteNamespaces = {
     [key: string]: string[];
 } | {
     [key: string]: string[];
     default: string[];
 };
+interface ApiHeaders {
+    authorization?: string;
+    "x-api-key"?: string;
+    [key: string]: string | undefined;
+}
 type BaseLoaderOptions = {
     basePath?: string;
     namespaces?: string[];
@@ -38,71 +59,83 @@ type ImportLoader = BaseLoaderOptions & {
 type ApiLoader = BaseLoaderOptions & {
     type: "api";
     apiUrl: string;
+    apiHeaders?: ApiHeaders;
     fullReload?: boolean;
 };
 type LoaderOptions = ImportLoader | ApiLoader;
 
-type InitLoggerOptions = {
+type LoggerOptions = {
     level?: Level;
     normalizerConfig?: NormalizerConfig;
     formatterConfig?: FormatterConfig;
     preset?: LoggerPreset;
 };
-type ResolvedLoggerOptions = InitLoggerOptions;
 
 declare const routingPrefix: readonly ["none", "all", "except-default"];
 declare const routingFirstVisitLocaleSource: readonly ["default", "browser"];
-type InitRoutingOptions = {
+type RoutingRawOptions = {
+    /** default: "none" */
     prefix?: (typeof routingPrefix)[number];
     firstVisit?: {
+        /** default: "browser" */
         localeSource?: (typeof routingFirstVisitLocaleSource)[number];
+        /** default: true */
         redirect?: boolean;
     };
+    /** default: "" */
     basePath?: string;
 };
-type ResolvedRoutingOptions = Required<InitRoutingOptions>;
+type RoutingResolvedOptions = Required<RoutingRawOptions>;
+
+type CacheRawOptions = {
+    enabled?: boolean;
+    /** default: 60\*60\*1000 (1 hour) */
+    ttl?: number;
+};
+type CacheResolvedOptions = Required<CacheRawOptions>;
 
-type InitTranslatorOptions = {
+type TranslatorOptions = {
     loadingMessage?: string;
     placeholder?: string;
 };
 
-type WithStaticMessages = {
-    loaderOptions?: undefined;
+type WithoutLoader = {
+    loader?: undefined;
     supportedLocales?: readonly Locale[];
 };
-type WithDynamicMessages = {
-    loaderOptions: LoaderOptions;
+type WithLoader = {
+    loader: LoaderOptions;
     supportedLocales: readonly Locale[];
 };
-type IntorInitConfig = (WithDynamicMessages | WithStaticMessages) & {
+type IntorRawConfig = (WithLoader | WithoutLoader) & {
     readonly id?: string;
     readonly messages?: LocaleNamespaceMessages;
     readonly defaultLocale: Locale;
     readonly fallbackLocales?: FallbackLocalesMap;
-    readonly translator?: InitTranslatorOptions;
-    readonly cookie?: InitCookieOptions;
-    readonly routing?: InitRoutingOptions;
-    readonly adapter?: IntorAdapter;
-    readonly logger?: InitLoggerOptions;
-    readonly prefixPlaceHolder?: string;
+    readonly translator?: TranslatorOptions;
+    readonly cookie?: CookieRawOptions;
+    readonly routing?: RoutingRawOptions;
+    readonly logger?: LoggerOptions;
+    readonly cache?: CacheRawOptions;
 };
-type IntorResolvedConfig = (WithDynamicMessages | WithStaticMessages) & {
+type IntorResolvedConfig = (WithLoader | WithoutLoader) & {
     readonly id: string;
     readonly messages?: LocaleNamespaceMessages;
     readonly defaultLocale: Locale;
     readonly fallbackLocales: FallbackLocalesMap;
-    readonly translator?: InitTranslatorOptions;
-    readonly cookie: ResolvedCookieOptions;
-    readonly routing: ResolvedRoutingOptions;
-    readonly adapter: IntorAdapter;
-    readonly logger?: ResolvedLoggerOptions;
-    readonly prefixPlaceHolder: string;
+    readonly translator?: TranslatorOptions;
+    readonly cookie: CookieResolvedOptions;
+    readonly routing: RoutingResolvedOptions;
+    readonly logger?: LoggerOptions;
+    readonly cache: CacheResolvedOptions;
 };
 
-/**
- * Define intor config
- */
-declare const defineIntorConfig: (config: IntorInitConfig) => IntorResolvedConfig;
+declare const defineIntorConfig: (config: IntorRawConfig) => IntorResolvedConfig;
+
+declare const DEFAULT_CACHE_OPTIONS: CacheResolvedOptions;
+
+declare const DEFAULT_COOKIE_OPTIONS: CookieResolvedOptions;
+
+declare const DEFAULT_ROUTING_OPTIONS: RoutingResolvedOptions;
 
-export { defineIntorConfig };
+export { DEFAULT_CACHE_OPTIONS, DEFAULT_COOKIE_OPTIONS, DEFAULT_ROUTING_OPTIONS, type IntorRawConfig, type IntorResolvedConfig, defineIntorConfig };

package/dist/config/index.d.ts

@@ -1,30 +1,51 @@
 import { Level, NormalizerConfig, FormatterConfig, LoggerPreset } from 'logry/edge';
 import { Locale, LocaleNamespaceMessages, FallbackLocalesMap } from 'intor-translator';
 
-type InitCookieOptions = {
+type CookieRawOptions = {
+    /** Completely disable cookie usage (no read, no write, no lookup by name) - default: false */
     disabled?: boolean;
+    /** Allow the system to automatically set cookies - default: true */
     autoSetCookie?: boolean;
+    /** default: "intor.i18n.locale" */
     name?: string;
-    maxAge?: number;
-    path?: string;
+    /** default: null */
     domain?: string | null;
-    secure?: boolean;
+    /** default: "/" */
+    path?: string;
+    /** default: 60 * 60 * 24 * 365 (365 days) */
+    maxAge?: number;
+    /** default: false */
     httpOnly?: boolean;
+    /** default: process.env.NODE_ENV !== "development" */
+    secure?: boolean;
+    /** default: lax */
     sameSite?: "lax" | "strict" | "none";
 };
-type ResolvedCookieOptions = Required<Omit<InitCookieOptions, "domain">> & {
+type CookieResolvedOptions = Required<Omit<CookieRawOptions, "domain">> & {
     domain: string | null;
 };
 
-declare const intorAdapters: readonly ["next-client", "next-server"];
-type IntorAdapter = (typeof intorAdapters)[number];
-
+/**
+ * ```ts
+ * {
+ *  default: ["ui", "meta"],
+ *  "/auth": ["auth", "admin"],
+ * }
+ * // When pathname is "/" => namespaces: ["ui", "meta"]
+ * // When pathname is "/auth" => namespaces: ["ui", "meta", "auth", "admin"]
+ * ```
+ */
 type RouteNamespaces = {
     [key: string]: string[];
 } | {
     [key: string]: string[];
     default: string[];
 };
+interface ApiHeaders {
+    authorization?: string;
+    "x-api-key"?: string;
+    [key: string]: string | undefined;
+}
 type BaseLoaderOptions = {
     basePath?: string;
     namespaces?: string[];
@@ -38,71 +59,83 @@ type ImportLoader = BaseLoaderOptions & {
 type ApiLoader = BaseLoaderOptions & {
     type: "api";
     apiUrl: string;
+    apiHeaders?: ApiHeaders;
     fullReload?: boolean;
 };
 type LoaderOptions = ImportLoader | ApiLoader;
 
-type InitLoggerOptions = {
+type LoggerOptions = {
     level?: Level;
     normalizerConfig?: NormalizerConfig;
     formatterConfig?: FormatterConfig;
     preset?: LoggerPreset;
 };
-type ResolvedLoggerOptions = InitLoggerOptions;
 
 declare const routingPrefix: readonly ["none", "all", "except-default"];
 declare const routingFirstVisitLocaleSource: readonly ["default", "browser"];
-type InitRoutingOptions = {
+type RoutingRawOptions = {
+    /** default: "none" */
     prefix?: (typeof routingPrefix)[number];
     firstVisit?: {
+        /** default: "browser" */
         localeSource?: (typeof routingFirstVisitLocaleSource)[number];
+        /** default: true */
         redirect?: boolean;
     };
+    /** default: "" */
     basePath?: string;
 };
-type ResolvedRoutingOptions = Required<InitRoutingOptions>;
+type RoutingResolvedOptions = Required<RoutingRawOptions>;
+
+type CacheRawOptions = {
+    enabled?: boolean;
+    /** default: 60\*60\*1000 (1 hour) */
+    ttl?: number;
+};
+type CacheResolvedOptions = Required<CacheRawOptions>;
 
-type InitTranslatorOptions = {
+type TranslatorOptions = {
     loadingMessage?: string;
     placeholder?: string;
 };
 
-type WithStaticMessages = {
-    loaderOptions?: undefined;
+type WithoutLoader = {
+    loader?: undefined;
     supportedLocales?: readonly Locale[];
 };
-type WithDynamicMessages = {
-    loaderOptions: LoaderOptions;
+type WithLoader = {
+    loader: LoaderOptions;
     supportedLocales: readonly Locale[];
 };
-type IntorInitConfig = (WithDynamicMessages | WithStaticMessages) & {
+type IntorRawConfig = (WithLoader | WithoutLoader) & {
     readonly id?: string;
     readonly messages?: LocaleNamespaceMessages;
     readonly defaultLocale: Locale;
     readonly fallbackLocales?: FallbackLocalesMap;
-    readonly translator?: InitTranslatorOptions;
-    readonly cookie?: InitCookieOptions;
-    readonly routing?: InitRoutingOptions;
-    readonly adapter?: IntorAdapter;
-    readonly logger?: InitLoggerOptions;
-    readonly prefixPlaceHolder?: string;
+    readonly translator?: TranslatorOptions;
+    readonly cookie?: CookieRawOptions;
+    readonly routing?: RoutingRawOptions;
+    readonly logger?: LoggerOptions;
+    readonly cache?: CacheRawOptions;
 };
-type IntorResolvedConfig = (WithDynamicMessages | WithStaticMessages) & {
+type IntorResolvedConfig = (WithLoader | WithoutLoader) & {
     readonly id: string;
     readonly messages?: LocaleNamespaceMessages;
     readonly defaultLocale: Locale;
     readonly fallbackLocales: FallbackLocalesMap;
-    readonly translator?: InitTranslatorOptions;
-    readonly cookie: ResolvedCookieOptions;
-    readonly routing: ResolvedRoutingOptions;
-    readonly adapter: IntorAdapter;
-    readonly logger?: ResolvedLoggerOptions;
-    readonly prefixPlaceHolder: string;
+    readonly translator?: TranslatorOptions;
+    readonly cookie: CookieResolvedOptions;
+    readonly routing: RoutingResolvedOptions;
+    readonly logger?: LoggerOptions;
+    readonly cache: CacheResolvedOptions;
 };
 
-/**
- * Define intor config
- */
-declare const defineIntorConfig: (config: IntorInitConfig) => IntorResolvedConfig;
+declare const defineIntorConfig: (config: IntorRawConfig) => IntorResolvedConfig;
+
+declare const DEFAULT_CACHE_OPTIONS: CacheResolvedOptions;
+
+declare const DEFAULT_COOKIE_OPTIONS: CookieResolvedOptions;
+
+declare const DEFAULT_ROUTING_OPTIONS: RoutingResolvedOptions;
 
-export { defineIntorConfig };
+export { DEFAULT_CACHE_OPTIONS, DEFAULT_COOKIE_OPTIONS, DEFAULT_ROUTING_OPTIONS, type IntorRawConfig, type IntorResolvedConfig, defineIntorConfig };