npm - intor - Versions diffs - 2.2.13 → 2.2.15 - Mend

intor 2.2.13 → 2.2.15

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (246) hide show

package/dist/src/client/react/contexts/locale/types.d.ts ADDED Viewed

@@ -0,0 +1,13 @@
+import type { Locale } from "intor-translator";
+import type * as React from "react";
+export type LocaleContextValue = {
+    locale: Locale;
+    setLocale: (locale: Locale) => void;
+};
+export type LocaleProviderProps = {
+    value: {
+        initialLocale: string;
+        onLocaleChange?: (newLocale: string) => Promise<void> | void;
+    };
+    children: React.ReactNode;
+};

package/dist/src/client/react/contexts/locale/utils/change-locale.d.ts ADDED Viewed

@@ -0,0 +1,22 @@
+import type { CookieResolvedOptions } from "../../../../../config/types/cookie.types";
+import type { LoaderOptions } from "../../../../../config/types/loader.types";
+import type { Locale } from "intor-translator";
+type Params = {
+    currentLocale: Locale;
+    newLocale: Locale;
+    loader?: LoaderOptions;
+    cookie: CookieResolvedOptions;
+    setLocale: (locale: Locale) => void;
+    refetchMessages?: (locale: Locale) => Promise<void>;
+};
+/**
+ * Change the locale on the client side.
+ *
+ * The following steps will be performed:
+ * 1. Update the locale state
+ * 2. Set the locale cookie (if not disabled and autoSetCookie is enabled)
+ * 3. Update the <html lang> attribute
+ * 4. Refetch messages if using a remote API loader
+ */
+export declare const changeLocale: ({ currentLocale, newLocale, loader, cookie, setLocale, refetchMessages, }: Params) => void;
+export {};

package/dist/src/client/react/contexts/locale/utils/change-locale.js ADDED Viewed

@@ -0,0 +1,35 @@
+import { setLocaleCookieBrowser } from '../../../../../shared/utils/client/set-locale-cookie-browser.js';
+/**
+ * Change the locale on the client side.
+ *
+ * The following steps will be performed:
+ * 1. Update the locale state
+ * 2. Set the locale cookie (if not disabled and autoSetCookie is enabled)
+ * 3. Update the <html lang> attribute
+ * 4. Refetch messages if using a remote API loader
+ */
+const changeLocale = ({ currentLocale, newLocale, loader, cookie, setLocale, refetchMessages, }) => {
+    if (typeof document === "undefined")
+        return;
+    const { type } = loader || {};
+    // Exit early if the new locale is the same as the current one
+    if (newLocale === currentLocale)
+        return;
+    // Warn: Using dynamic local cannot switch locale with CSR only
+    if (type === "local") {
+        console.warn(`[Intor] You are using "loader type: local" to switch languages. Please make sure to use the wrapped <Link> component to trigger a page reload, ensuring that the translation data is dynamically updated.`);
+    }
+    // Update the locale state
+    setLocale(newLocale);
+    // Set the locale cookie on client side
+    setLocaleCookieBrowser({ cookie, locale: newLocale });
+    // Update the <html lang> attribute
+    document.documentElement.lang = newLocale;
+    // Refetch messages via remote API, if applicable
+    if (type === "remote" && refetchMessages) {
+        void refetchMessages(newLocale);
+    }
+};
+export { changeLocale };

package/dist/src/client/react/contexts/locale/utils/use-init-locale-cookie.d.ts ADDED Viewed

@@ -0,0 +1,8 @@
+import type { IntorResolvedConfig } from "../../../../../config/types/intor-config.types";
+/**
+ * Init locale cookie
+ */
+export declare const useInitLocaleCookie: ({ config, locale, }: {
+    config: IntorResolvedConfig;
+    locale: string;
+}) => void;

package/dist/src/client/react/contexts/locale/utils/use-init-locale-cookie.js ADDED Viewed

@@ -0,0 +1,28 @@
+import * as React from 'react';
+import { setLocaleCookieBrowser } from '../../../../../shared/utils/client/set-locale-cookie-browser.js';
+/**
+ * Init locale cookie
+ */
+const useInitLocaleCookie = ({ config, locale, }) => {
+    React.useEffect(() => {
+        if (typeof document === "undefined")
+            return;
+        const { cookie, routing } = config;
+        const { firstVisit } = routing;
+        const cookies = document.cookie.split(";").map((c) => c.trim());
+        const isCookieExists = cookies.some((c) => c.startsWith(`${cookie.name}=`));
+        // Cookie already exists
+        if (isCookieExists)
+            return;
+        // If first visit is not using redirect, do not set cookie
+        if (!firstVisit.redirect)
+            return;
+        // Cookie is disabled or autoSetCookie is disabled
+        if (!cookie.enabled || !cookie.autoSetCookie)
+            return;
+        setLocaleCookieBrowser({ cookie, locale });
+    }, []); // Mount only once
+};
+export { useInitLocaleCookie };

package/dist/src/client/react/contexts/messages/context.d.ts ADDED Viewed

@@ -0,0 +1,3 @@
+import type { MessagesContextValue } from "./types";
+import * as React from "react";
+export declare const MessagesContext: React.Context<MessagesContextValue | undefined>;

package/dist/src/client/react/contexts/messages/context.js ADDED Viewed

@@ -0,0 +1,6 @@
+import * as React from 'react';
+// context
+const MessagesContext = React.createContext(undefined);
+export { MessagesContext };

package/dist/src/client/react/contexts/messages/hook.d.ts ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ import type { MessagesContextValue } from "./types";
2	+ export declare function useMessages(): MessagesContextValue;

package/dist/src/client/react/contexts/messages/hook.js ADDED Viewed

@@ -0,0 +1,12 @@
+import * as React from 'react';
+import { MessagesContext } from './context.js';
+// hook
+function useMessages() {
+    const context = React.useContext(MessagesContext);
+    if (!context)
+        throw new Error("useMessages must be used within a MessagesProvider");
+    return context;
+}
+export { useMessages };

package/dist/src/client/react/contexts/messages/index.d.ts ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ export { MessagesProvider } from "./provider";
2	+ export { useMessages } from "./hook";

package/dist/src/client/react/contexts/messages/provider.d.ts ADDED Viewed

@@ -0,0 +1,3 @@
+import type { MessagesProviderProps } from "./types";
+import * as React from "react";
+export declare function MessagesProvider({ value: { messages }, children, }: MessagesProviderProps): React.JSX.Element;

package/dist/src/client/react/contexts/messages/provider.js ADDED Viewed

@@ -0,0 +1,32 @@
+"use client";
+import { jsx } from 'react/jsx-runtime';
+import * as React from 'react';
+import '../config/context.js';
+import { useConfig } from '../config/hook.js';
+import { useRefetchMessages } from './utils/use-refetch-messages.js';
+import { MessagesContext } from './context.js';
+// provider
+function MessagesProvider({ value: { messages = {} }, children, }) {
+    const { config, pathname } = useConfig();
+    const [loadedMessages, setLoadedMessages] = React.useState(null);
+    const [isLoadingMessages, setIsLoadingMessages] = React.useState(false);
+    // Setup refetch messages function
+    const { refetchMessages } = useRefetchMessages({
+        config,
+        pathname,
+        setLoadedMessages,
+        setIsLoadingMessages,
+    });
+    // context value
+    const value = React.useMemo(() => ({
+        messages: loadedMessages || messages,
+        isLoading: isLoadingMessages,
+        setLoadedMessages,
+        setIsLoadingMessages,
+        refetchMessages,
+    }), [loadedMessages, messages, isLoadingMessages, refetchMessages]);
+    return (jsx(MessagesContext.Provider, { value: value, children: children }));
+}
+export { MessagesProvider };

package/dist/src/client/react/contexts/messages/types.d.ts ADDED Viewed

@@ -0,0 +1,15 @@
+import type { LocaleMessages } from "intor-translator";
+import type * as React from "react";
+export type MessagesContextValue = {
+    messages: Readonly<LocaleMessages>;
+    isLoading: boolean;
+    setLoadedMessages: React.Dispatch<React.SetStateAction<LocaleMessages | null>>;
+    setIsLoadingMessages: React.Dispatch<React.SetStateAction<boolean>>;
+    refetchMessages: (newLocale: string) => Promise<void>;
+};
+export type MessagesProviderProps = {
+    value: {
+        messages?: Readonly<LocaleMessages>;
+    };
+    children: React.ReactNode;
+};

package/dist/src/client/react/contexts/messages/utils/use-refetch-messages.d.ts ADDED Viewed

@@ -0,0 +1,16 @@
+import type { IntorResolvedConfig } from "../../../../../config/types/intor-config.types";
+import type { LocaleMessages } from "intor-translator";
+import * as React from "react";
+type UseRefetchMessagesParams = {
+    config: IntorResolvedConfig;
+    pathname: string;
+    setLoadedMessages: React.Dispatch<React.SetStateAction<LocaleMessages | null>>;
+    setIsLoadingMessages: React.Dispatch<React.SetStateAction<boolean>>;
+};
+/**
+ * Refetch messages (Dynamic API)
+ */
+export declare const useRefetchMessages: ({ config, pathname, setLoadedMessages, setIsLoadingMessages, }: UseRefetchMessagesParams) => {
+    refetchMessages: (newLocale: string) => Promise<void>;
+};
+export {};

package/dist/src/client/react/contexts/messages/utils/use-refetch-messages.js ADDED Viewed

@@ -0,0 +1,57 @@
+import * as React from 'react';
+import '../../../../../config/constants/cache.constants.js';
+import { mergeMessages } from '../../../../../shared/utils/merge-messages.js';
+import { resolveNamespaces } from '../../../../../shared/utils/resolve-namespaces.js';
+import { loadRemoteMessages } from '../../../../../server/messages/load-remote-messages/load-remote-messages.js';
+/**
+ * Refetch messages (Dynamic API)
+ */
+const useRefetchMessages = ({ config, pathname, setLoadedMessages, setIsLoadingMessages, }) => {
+    const { messages: staticMessages, loader } = config;
+    const namespaces = React.useMemo(() => {
+        if (!loader)
+            return [];
+        return resolveNamespaces({ config, pathname });
+    }, [config, pathname]);
+    // Refetch messages
+    const refetchMessages = React.useCallback(async (newLocale) => {
+        if (loader?.type === "remote") {
+            setIsLoadingMessages(true);
+            const loadedMessages = await loadRemoteMessages({
+                rootDir: loader.rootDir,
+                remoteUrl: loader.remoteUrl,
+                remoteHeaders: loader.remoteHeaders,
+                locale: newLocale,
+                fallbackLocales: config.fallbackLocales[newLocale] || [],
+                namespaces,
+                extraOptions: {
+                    cacheOptions: config.cache,
+                    loggerOptions: { id: config.id },
+                },
+            });
+            const messages = mergeMessages(staticMessages, loadedMessages);
+            setLoadedMessages(messages);
+            setIsLoadingMessages(false);
+        }
+    }, [
+        loader,
+        config.fallbackLocales,
+        config.cache,
+        config.id,
+        setIsLoadingMessages,
+        namespaces,
+        staticMessages,
+        setLoadedMessages,
+    ]);
+    return { refetchMessages };
+};
+export { useRefetchMessages };

package/dist/src/client/react/contexts/translate-handlers/context.d.ts ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ import * as React from "react";
2	+ export declare const TranslateHandlersContext: React.Context<import("intor-translator").TranslateHandlers \| undefined>;

package/dist/src/client/react/contexts/translate-handlers/context.js ADDED Viewed

@@ -0,0 +1,6 @@
+import * as React from 'react';
+// context
+const TranslateHandlersContext = React.createContext(undefined);
+export { TranslateHandlersContext };

package/dist/src/client/react/contexts/translate-handlers/hook.d.ts ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ import type { TranslateHandlersContextValue } from "../../../../client/react/contexts/translate-handlers/types";
2	+ export declare function useTranslateHandlers(): TranslateHandlersContextValue;

package/dist/src/client/react/contexts/translate-handlers/hook.js ADDED Viewed

@@ -0,0 +1,10 @@
+import * as React from 'react';
+import { TranslateHandlersContext } from './context.js';
+// hook
+function useTranslateHandlers() {
+    const context = React.useContext(TranslateHandlersContext);
+    return context;
+}
+export { useTranslateHandlers };

package/dist/src/client/react/contexts/translate-handlers/index.d.ts ADDED Viewed

@@ -0,0 +1,3 @@
+export { TranslateHandlersProvider } from "./provider";
+export { useTranslateHandlers } from "./hook";
+export type { TranslateHandlersProviderProps } from "./types";

package/dist/src/client/react/contexts/translate-handlers/provider.d.ts ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ import type { TranslateHandlersProviderProps } from "./types";
2	+ export declare const TranslateHandlersProvider: ({ handlers, children, }: TranslateHandlersProviderProps) => import("react/jsx-runtime").JSX.Element;

package/dist/src/client/react/contexts/translate-handlers/provider.js ADDED Viewed

@@ -0,0 +1,11 @@
+"use client";
+import { jsx } from 'react/jsx-runtime';
+import 'react';
+import { TranslateHandlersContext } from './context.js';
+// provider
+const TranslateHandlersProvider = ({ handlers, children, }) => {
+    return (jsx(TranslateHandlersContext.Provider, { value: handlers, children: children }));
+};
+export { TranslateHandlersProvider };

package/dist/src/client/react/contexts/translate-handlers/types.d.ts ADDED Viewed

@@ -0,0 +1,7 @@
+import type { TranslateHandlers } from "intor-translator";
+import type * as React from "react";
+export type TranslateHandlersContextValue = TranslateHandlers;
+export type TranslateHandlersProviderProps = {
+    handlers: TranslateHandlers;
+    children: React.ReactNode;
+};

package/dist/src/client/react/contexts/translator/context.d.ts ADDED Viewed

@@ -0,0 +1,3 @@
+import type { TranslatorContextValue } from "./types";
+import * as React from "react";
+export declare const TranslatorContext: React.Context<TranslatorContextValue | undefined>;

package/dist/src/client/react/contexts/translator/context.js ADDED Viewed

@@ -0,0 +1,6 @@
+import * as React from 'react';
+// context
+const TranslatorContext = React.createContext(undefined);
+export { TranslatorContext };

package/dist/src/client/react/contexts/translator/hook.d.ts ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ import type { TranslatorContextValue } from "./types";
2	+ export declare function useTranslator<M>(): TranslatorContextValue<M>;

package/dist/src/client/react/contexts/translator/hook.js ADDED Viewed

@@ -0,0 +1,12 @@
+import * as React from 'react';
+import { TranslatorContext } from './context.js';
+// hook
+function useTranslator() {
+    const context = React.useContext(TranslatorContext);
+    if (!context)
+        throw new Error("useTranslator must be used within IntorTranslatorProvider");
+    return context;
+}
+export { useTranslator };

package/dist/src/client/react/contexts/translator/index.d.ts ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ export { TranslatorProvider } from "./provider";
2	+ export { useTranslator } from "./hook";

package/dist/src/client/react/contexts/translator/provider.d.ts ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ import type { TranslatorProviderProps } from "./types";
2	+ export declare function TranslatorProvider({ value: { isLoading: externalIsLoading }, children, }: TranslatorProviderProps): import("react/jsx-runtime").JSX.Element;

package/dist/src/client/react/contexts/translator/provider.js ADDED Viewed

@@ -0,0 +1,53 @@
+"use client";
+import { jsx } from 'react/jsx-runtime';
+import { Translator } from 'intor-translator';
+import * as React from 'react';
+import '../config/context.js';
+import { useConfig } from '../config/hook.js';
+import '../../../../config/constants/cache.constants.js';
+import '../messages/context.js';
+import { useMessages } from '../messages/hook.js';
+import '../locale/context.js';
+import { useLocale } from '../locale/hook.js';
+import '../translate-handlers/context.js';
+import { useTranslateHandlers } from '../translate-handlers/hook.js';
+import { TranslatorContext } from './context.js';
+// Translator Provider
+function TranslatorProvider({ value: { isLoading: externalIsLoading }, children, }) {
+    const { config } = useConfig();
+    const { messages, isLoading: internalIsLoading } = useMessages();
+    const { locale } = useLocale();
+    const translateHandlers = useTranslateHandlers();
+    const { fallbackLocales, translator: translatorOptions } = config;
+    const isLoading = Boolean(externalIsLoading ?? internalIsLoading);
+    const translator = React.useMemo(() => {
+        return new Translator({
+            messages,
+            locale,
+            isLoading,
+            fallbackLocales,
+            loadingMessage: translatorOptions?.loadingMessage,
+            placeholder: translatorOptions?.placeholder,
+            handlers: translateHandlers,
+        });
+    }, [
+        messages,
+        locale,
+        isLoading,
+        fallbackLocales,
+        translateHandlers,
+        translatorOptions?.loadingMessage,
+        translatorOptions?.placeholder,
+    ]);
+    return (jsx(TranslatorContext.Provider, { value: { translator }, children: children }));
+}
+export { TranslatorProvider };

package/dist/src/client/react/contexts/translator/types.d.ts ADDED Viewed

@@ -0,0 +1,11 @@
+import type { Translator } from "intor-translator";
+import type * as React from "react";
+export type TranslatorContextValue<M = unknown> = {
+    translator: Translator<M>;
+};
+export type TranslatorProviderProps = {
+    value: {
+        isLoading?: boolean;
+    };
+    children: React.ReactNode;
+};

package/dist/src/client/react/hooks/use-translator.d.ts ADDED Viewed

@@ -0,0 +1,12 @@
+import type { IfGen, GenConfigKeys, GenMessages } from "../../../shared/types/generated.types";
+import type { TranslatorInstance } from "../../../shared/types/translator-instance.types";
+import type { LocalizedNodeKeys } from "intor-translator";
+/**
+ * React hook to access a ready-to-use translator instance in the client.
+ *
+ * - Provides `t`, `hasKey`, `messages`, `locale`, `isLoading` and `setLocale`.
+ * - Supports optional `preKey` to create a scoped translator for nested keys.
+ * - Can accept a generic type parameter `M` to strongly type your messages.
+ */
+export declare function useTranslator<CK extends GenConfigKeys = "__default__">(): TranslatorInstance<GenMessages<CK>>;
+export declare function useTranslator<CK extends GenConfigKeys = "__default__", PK extends string = LocalizedNodeKeys<GenMessages<CK>>>(preKey: IfGen<PK, string>): TranslatorInstance<GenMessages<CK>, PK>;

package/dist/src/client/react/hooks/use-translator.js ADDED Viewed

@@ -0,0 +1,38 @@
+import 'react/jsx-runtime';
+import 'react';
+import '../contexts/config/context.js';
+import '../../../config/constants/cache.constants.js';
+import '../contexts/messages/context.js';
+import '../contexts/locale/context.js';
+import { useLocale } from '../contexts/locale/hook.js';
+import 'intor-translator';
+import '../contexts/translate-handlers/context.js';
+import '../contexts/translator/context.js';
+import { useTranslator as useTranslator$1 } from '../contexts/translator/hook.js';
+// Implementation
+function useTranslator(preKey) {
+    const { translator } = useTranslator$1();
+    const { setLocale } = useLocale();
+    const props = {
+        messages: translator.messages,
+        locale: translator.locale,
+        isLoading: translator.isLoading,
+        setLocale,
+    };
+    const scoped = translator.scoped(preKey);
+    return {
+        ...props,
+        hasKey: preKey ? scoped.hasKey : translator.hasKey,
+        t: preKey ? scoped.t : translator.t,
+    };
+}
+export { useTranslator };

package/dist/src/client/react/index.d.ts ADDED Viewed

@@ -0,0 +1,4 @@
+export { IntorProvider, type IntorProviderProps, } from "./contexts/intor-provider";
+export { TranslateHandlersProvider, type TranslateHandlersProviderProps, } from "./contexts/translate-handlers";
+export { useTranslator } from "./hooks/use-translator";
+export { getInitialLocale } from "../../client/shared/utils/get-initial-locale";

package/dist/src/client/shared/utils/get-initial-locale.d.ts ADDED Viewed

@@ -0,0 +1,11 @@
+import type { IntorResolvedConfig } from "../../../config";
+/**
+ * Get the initial locale from cookie, browser, or default.
+ *
+ * - This function is intended for client-side use only.
+ *
+ * @param {IntorResolvedConfig} config - The intor configuration.
+ * @param {string} [cookieName=config.cookie.name] - Optional cookie name to check.
+ * @returns {string} The matched locale or the default locale.
+ */
+export declare function getInitialLocale(config: IntorResolvedConfig, cookieName?: string): string;

package/dist/src/client/shared/utils/get-initial-locale.js ADDED Viewed

@@ -0,0 +1,21 @@
+/**
+ * Get the initial locale from cookie, browser, or default.
+ *
+ * - This function is intended for client-side use only.
+ *
+ * @param {IntorResolvedConfig} config - The intor configuration.
+ * @param {string} [cookieName=config.cookie.name] - Optional cookie name to check.
+ * @returns {string} The matched locale or the default locale.
+ */
+function getInitialLocale(config, cookieName = config.cookie.name) {
+    const { defaultLocale, supportedLocales } = config;
+    const match = document.cookie.match(new RegExp(`(?:^|; )${cookieName.replaceAll(/([.$?*|{}()[\]\\/+^])/g, String.raw `\$1`)}=([^;]*)`));
+    const cookieLocale = match ? decodeURIComponent(match[1]) : null;
+    const browserLocale = navigator.languages?.[0] || navigator.language;
+    const locale = cookieLocale || browserLocale || defaultLocale;
+    const normalized = locale.toLowerCase();
+    const matched = supportedLocales.find((l) => l.toLowerCase() === normalized);
+    return matched ?? defaultLocale;
+}
+export { getInitialLocale };

package/dist/src/config/constants/cache.constants.d.ts ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ import type { CacheResolvedOptions } from "../../config/types/cache.types";
2	+ export declare const DEFAULT_CACHE_OPTIONS: CacheResolvedOptions;

package/dist/src/config/constants/cache.constants.js ADDED Viewed

@@ -0,0 +1,7 @@
+// Default cache options
+const DEFAULT_CACHE_OPTIONS = {
+    enabled: process.env.NODE_ENV === "production",
+    ttl: 60 * 60 * 1000, // 1 hour
+};
+export { DEFAULT_CACHE_OPTIONS };

package/dist/src/config/constants/cookie.constants.d.ts ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ import type { CookieResolvedOptions } from "../../config/types/cookie.types";
2	+ export declare const DEFAULT_COOKIE_OPTIONS: CookieResolvedOptions;

package/dist/src/config/constants/cookie.constants.js ADDED Viewed

@@ -0,0 +1,14 @@
+// Default cookie options
+const DEFAULT_COOKIE_OPTIONS = {
+    enabled: true,
+    autoSetCookie: true,
+    name: "intor.i18n.locale",
+    domain: null,
+    path: "/",
+    maxAge: 60 * 60 * 24 * 365, // 365 days
+    httpOnly: false,
+    secure: process.env.NODE_ENV !== "development",
+    sameSite: "lax",
+};
+export { DEFAULT_COOKIE_OPTIONS };

package/dist/src/config/constants/routing.constants.d.ts ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ import type { RoutingResolvedOptions } from "../../config/types/routing.types";
2	+ export declare const DEFAULT_ROUTING_OPTIONS: RoutingResolvedOptions;

package/dist/src/config/constants/routing.constants.js ADDED Viewed

@@ -0,0 +1,11 @@
+// Default routing options
+const DEFAULT_ROUTING_OPTIONS = {
+    prefix: "none",
+    firstVisit: {
+        localeSource: "browser",
+        redirect: true,
+    },
+    basePath: "/",
+};
+export { DEFAULT_ROUTING_OPTIONS };

package/dist/src/config/define-intor-config.d.ts ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ import type { IntorRawConfig, IntorResolvedConfig } from "../config/types/intor-config.types";
2	+ export declare const defineIntorConfig: (config: IntorRawConfig) => IntorResolvedConfig;

package/dist/src/config/define-intor-config.js ADDED Viewed

@@ -0,0 +1,34 @@
+import { resolveCacheOptions } from './resolvers/resolve-cache-options.js';
+import { resolveCookieOptions } from './resolvers/resolve-cookie-options.js';
+import { resolveFallbackLocales } from './resolvers/resolve-fallback-locales.js';
+import { resolveRoutingOptions } from './resolvers/resolve-routing-options.js';
+import { validateDefaultLocale } from './validators/validate-default-locale.js';
+import { validateSupportedLocales } from './validators/validate-supported-locales.js';
+const defineIntorConfig = (config) => {
+    // Generate a random id if config.id is not defined
+    const id = config.id || `ID${Math.random().toString(36).slice(2, 6)}`;
+    // Validaters
+    const supportedLocales = validateSupportedLocales(config);
+    const defaultLocale = validateDefaultLocale(config, supportedLocales);
+    // Resolvers
+    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,
+        loader: config.loader,
+        defaultLocale,
+        supportedLocales,
+        fallbackLocales,
+        translator: config.translator,
+        cookie,
+        routing,
+        logger: config.logger,
+        cache,
+    };
+};
+export { defineIntorConfig };

package/dist/src/config/index.d.ts ADDED Viewed

@@ -0,0 +1,5 @@
+export { defineIntorConfig } from "./define-intor-config";
+export { DEFAULT_CACHE_OPTIONS } from "./constants/cache.constants";
+export { DEFAULT_COOKIE_OPTIONS } from "./constants/cookie.constants";
+export { DEFAULT_ROUTING_OPTIONS } from "./constants/routing.constants";
+export type { IntorRawConfig, IntorResolvedConfig, } from "./types/intor-config.types";

package/dist/src/config/resolvers/resolve-cache-options.d.ts ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ import type { CacheRawOptions, CacheResolvedOptions } from "../../config/types/cache.types";
2	+ export declare const resolveCacheOptions: (cache?: CacheRawOptions) => CacheResolvedOptions;