intor 2.4.6 → 2.4.8

package/dist/svelte-kit/src/server/messages/load-local-messages/read-locale-messages/collect-file-entries/collect-file-entries.js

@@ -1,91 +0,0 @@
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import '../../../../../core/error/intor-error.js';
-import { getLogger } from '../../../../../core/logger/get-logger.js';
-import 'p-limit';
-import 'intor-translator';
-
-/**
- * Recursively collects message file metadata under a given locale root.
- *
- * - Traverses directories and collects matching message files
- * - Supports filtering by file extensions and optional namespaces
- *
- * @example
- * ```ts
- * [{
- *     namespace: "auth", // If messages under locale root (no namespace) -> "index"
- *     fullPath: "/Users/john/my-app/messages/en-US/auth/login.json",
- *     relativePath: "auth/login.json",
- *     segments: ["auth", "login"],
- *     basename: "login",
- * }, ... ];
- * ```
- */
-async function collectFileEntries({ readdir = fs.readdir, namespaces, rootDir, limit, exts = [], loggerOptions, }) {
-    const baseLogger = getLogger(loggerOptions);
-    const logger = baseLogger.child({ scope: "collect-file-entries" });
-    const supportedExts = new Set(["json", ...exts]);
-    const fileEntries = [];
-    // Recursive directory walk
-    const walk = async (currentDir) => {
-        // -------------------------------------------------------------------------
-        // Read directory entries
-        // -------------------------------------------------------------------------
-        let entries = [];
-        try {
-            entries = await readdir(currentDir, { withFileTypes: true });
-        }
-        catch {
-            logger.debug("Locale directory not found, skipping locale.", {
-                localeDir: currentDir,
-            });
-            return;
-        }
-        // -------------------------------------------------------------------------
-        // 1. Recurse into sub-directories (control flow, no limit)
-        // -------------------------------------------------------------------------
-        for (const entry of entries) {
-            if (!entry.isDirectory())
-                continue;
-            await walk(path.join(currentDir, entry.name));
-        }
-        // -------------------------------------------------------------------------
-        // 2. Process files (IO-bound, concurrency-limited)
-        // -------------------------------------------------------------------------
-        const tasks = entries
-            .filter((entry) => entry.isFile())
-            .map((entry) => limit(async () => {
-            const fullPath = path.join(currentDir, entry.name);
-            const ext = path.extname(entry.name).slice(1);
-            if (!ext || !supportedExts.has(ext))
-                return;
-            const relativePath = path.relative(rootDir, fullPath);
-            const withoutExt = relativePath.slice(0, relativePath.length - (ext.length + 1));
-            const segments = withoutExt.split(path.sep).filter(Boolean);
-            const namespace = segments.at(0);
-            if (!namespace)
-                return;
-            // Apply namespace filter (always allow "index")
-            if (namespaces && namespace !== "index") {
-                if (!namespaces.includes(namespace))
-                    return;
-            }
-            fileEntries.push({
-                namespace,
-                fullPath,
-                relativePath,
-                segments,
-                basename: path.basename(entry.name, `.${ext}`),
-            });
-        }));
-        await Promise.all(tasks);
-    };
-    await walk(rootDir);
-    if (fileEntries.length > 0) {
-        logger.trace(`Collected ${fileEntries.length} local message files for locale "${path.basename(rootDir)}".`);
-    }
-    return fileEntries;
-}
-
-export { collectFileEntries };

package/dist/svelte-kit/src/server/messages/load-local-messages/read-locale-messages/parse-file-entries/parse-file-entries.js

@@ -1,103 +0,0 @@
-import path from 'node:path';
-import '../../../../../core/error/intor-error.js';
-import { deepMerge } from '../../../../../core/utils/deep-merge.js';
-import { getLogger } from '../../../../../core/logger/get-logger.js';
-import 'p-limit';
-import { isValidMessages } from '../../../../../core/messages/utils/is-valid-messages.js';
-import { nestObjectFromPath } from '../../../../../core/messages/utils/nest-object-from-path.js';
-import 'intor-translator';
-import { jsonReader } from './utils/json-reader.js';
-
-/**
- * Parse locale message files into a unified Messages object (single-locale).
- *
- * - Reads JSON or custom formats (via `messagesReader`)
- * - Validates message structure
- * - Builds nested objects based on file path segments
- * - Deep-merges entries by namespace
- *
- * @example
- * ```plain
- * File paths:
- *   - en/index.json        = { a: "A" }
- *   - en/ui.json           = { b: "B" }
- *   - en/auth/index.json   = { c: "C" }
- *   - en/auth/verify.json  = { d: "D" }
- *```
-
- * The final return value is a `Messages` object:
- * ```ts
- * {
- *   a: "A",
- *   ui: { b: "B" },
- *   auth: {
- *     c: "C",
- *     verify: { d: "D" },
- *   },
- * }
- * ```
- */
-async function parseFileEntries({ fileEntries, limit, readers, loggerOptions, }) {
-    const baseLogger = getLogger(loggerOptions);
-    const logger = baseLogger.child({ scope: "parse-file-entries" });
-    // Read and parse all file entries
-    const parsedFileEntries = [];
-    const tasks = fileEntries.map(({ namespace, segments, basename, fullPath }) => limit(async () => {
-        try {
-            // -------------------------------------------------------------------
-            // Read and validate file content
-            // -------------------------------------------------------------------
-            const ext = path.extname(fullPath).slice(1); // remove dot
-            let raw;
-            if (ext === "json") {
-                raw = await jsonReader(fullPath);
-            }
-            else {
-                const reader = readers?.[ext];
-                if (!reader) {
-                    throw new Error(`No message reader registered for .${ext} files. ` +
-                        `Please register a reader for the "${ext}" extension.`);
-                }
-                raw = await reader(fullPath);
-            }
-            // Validate messages structure
-            if (!isValidMessages(raw)) {
-                throw new Error("Parsed content does not match expected Messages structure");
-            }
-            // -------------------------------------------------------------------
-            // Build nested message object from path segments
-            // -------------------------------------------------------------------
-            const segmentsWithoutNamespace = segments.slice(1);
-            const isIndexFile = basename === "index";
-            const keyPath = isIndexFile
-                ? segmentsWithoutNamespace.slice(0, -1)
-                : segmentsWithoutNamespace;
-            // Nest the parsed content based on the path segments
-            const nestedMessages = nestObjectFromPath(keyPath, raw);
-            parsedFileEntries.push({ namespace, messages: nestedMessages });
-        }
-        catch (error) {
-            logger.warn("Failed to read or parse file.", {
-                path: fullPath,
-                error,
-            });
-        }
-    }));
-    await Promise.all(tasks);
-    // ---------------------------------------------------------------------------
-    // Merge parsed entries by namespace
-    // ---------------------------------------------------------------------------
-    const result = {};
-    for (const { namespace, messages } of parsedFileEntries) {
-        // Root-level namespace (e.g. [locale]/index.json)
-        if (namespace === "index") {
-            Object.assign(result, deepMerge(result, messages));
-        }
-        else {
-            result[namespace] = deepMerge(result[namespace], messages);
-        }
-    }
-    return result;
-}
-
-export { parseFileEntries };

package/dist/svelte-kit/src/server/messages/load-local-messages/read-locale-messages/parse-file-entries/utils/json-reader.js

@@ -1,12 +0,0 @@
-import fs from 'node:fs/promises';
-
-/**
- *  Read & parse a JSON file
- */
-async function jsonReader(filePath, readFile = fs.readFile) {
-    const raw = await readFile(filePath, "utf8");
-    const parsed = JSON.parse(raw);
-    return parsed;
-}
-
-export { jsonReader };

package/dist/svelte-kit/src/server/messages/load-local-messages/read-locale-messages/read-locale-messages.js

@@ -1,42 +0,0 @@
-import path from 'node:path';
-import { collectFileEntries } from './collect-file-entries/collect-file-entries.js';
-import { parseFileEntries } from './parse-file-entries/parse-file-entries.js';
-
-/**
- * Read and assemble messages for a single locale from the file system.
- *
- * This function acts as a thin orchestration layer:
- * - Collects message file metadata for the locale
- * - Parses files into a single Messages object
- * - Wraps the result under the locale key
- *
- * It does not perform validation or transformation itself.
- */
-const readLocaleMessages = async ({ locale, namespaces, rootDir = "messages", limit, readers, loggerOptions, }) => {
-    // ---------------------------------------------------------------------------
-    // Collect message file entries for the locale
-    // ---------------------------------------------------------------------------
-    const fileEntries = await collectFileEntries({
-        namespaces,
-        rootDir: path.resolve(rootDir, locale),
-        limit,
-        exts: Object.keys(readers || {}),
-        loggerOptions,
-    });
-    // ---------------------------------------------------------------------------
-    // Parse collected files into a Messages object (single-locale)
-    // ---------------------------------------------------------------------------
-    const messages = await parseFileEntries({
-        fileEntries,
-        limit,
-        readers,
-        loggerOptions,
-    });
-    // ---------------------------------------------------------------------------
-    // Wrap parsed messages under the locale key
-    // ---------------------------------------------------------------------------
-    const localeMessages = { [locale]: messages };
-    return localeMessages;
-};
-
-export { readLocaleMessages };

package/dist/svelte-kit/src/server/messages/load-messages.js

@@ -1,78 +0,0 @@
-import '../../core/error/intor-error.js';
-import { resolveLoaderOptions } from '../../core/utils/resolve-loader-options.js';
-import { getLogger } from '../../core/logger/get-logger.js';
-import { loadRemoteMessages } from '../../core/messages/load-remote-messages/load-remote-messages.js';
-import 'intor-translator';
-import { loadLocalMessages } from './load-local-messages/load-local-messages.js';
-
-/**
- * Load locale messages according to the resolved Intor loader configuration.
- *
- * This function is the top-level orchestration entry for message loading.
- * It is responsible for:
- *
- * - Resolving the active loader strategy (local or remote)
- * - Dispatching to the appropriate loader implementation
- * - Passing through cache and read-related options
- *
- * Message traversal, parsing, fallback resolution, and caching logic
- * are delegated to the selected loader.
- */
-const loadMessages = async ({ config, locale, readers, allowCacheWrite = false, fetch, }) => {
-    const baseLogger = getLogger(config.logger);
-    const logger = baseLogger.child({ scope: "load-messages" });
-    // ---------------------------------------------------------------------------
-    // Resolve loader configuration
-    // ---------------------------------------------------------------------------
-    const loader = resolveLoaderOptions(config, "server");
-    if (!loader) {
-        logger.warn("No loader options have been configured in the current config.");
-        return;
-    }
-    const { mode, namespaces, concurrency } = loader;
-    const fallbackLocales = config.fallbackLocales[locale] || [];
-    logger.info(`Loading messages for locale "${locale}".`);
-    logger.trace("Starting to load messages with runtime context.", {
-        loaderMode: mode,
-        ...(mode === "local" ? { rootDir: loader.rootDir } : {}),
-        locale,
-        fallbackLocales: fallbackLocales.join(", "),
-        namespaces: namespaces && namespaces.length > 0 ? [...namespaces] : "*",
-    });
-    // ---------------------------------------------------------------------------
-    // Dispatch to loader implementation
-    // ---------------------------------------------------------------------------
-    let loadedMessages;
-    if (mode === "local") {
-        loadedMessages = await loadLocalMessages({
-            id: config.id,
-            locale,
-            fallbackLocales,
-            namespaces,
-            rootDir: loader.rootDir,
-            concurrency,
-            readers,
-            allowCacheWrite,
-            loggerOptions: config.logger,
-        });
-    }
-    else if (mode === "remote") {
-        loadedMessages = await loadRemoteMessages({
-            locale,
-            fallbackLocales,
-            namespaces,
-            concurrency,
-            fetch,
-            url: loader.url,
-            headers: loader.headers,
-            loggerOptions: config.logger,
-        });
-    }
-    // Final sanity check
-    if (!loadedMessages || Object.keys(loadedMessages).length === 0) {
-        logger.warn("No messages found.", { locale, fallbackLocales, namespaces });
-    }
-    return loadedMessages;
-};
-
-export { loadMessages };

package/dist/svelte-kit/src/server/translator/init-translator.js

@@ -1,36 +0,0 @@
-import '../../core/error/intor-error.js';
-import { resolveLoaderOptions } from '../../core/utils/resolve-loader-options.js';
-import 'logry';
-import 'p-limit';
-import { createTranslator } from '../../core/translator/create-translator.js';
-import 'intor-translator';
-import { loadMessages } from '../messages/load-messages.js';
-import 'node:path';
-import 'node:fs/promises';
-
-/**
- * Initialize a locale-bound Translator snapshot.
- *
- * - Resolves loader options and loads messages if configured
- * - Creates an immutable Translator instance for server usage
- */
-async function initTranslator(config, locale, options) {
-    const { readers, allowCacheWrite = false, fetch, handlers, plugins, } = options;
-    const loader = resolveLoaderOptions(config, "server");
-    // Load messages
-    let messages = {};
-    if (loader) {
-        const loaded = await loadMessages({
-            config,
-            locale,
-            readers,
-            allowCacheWrite,
-            fetch,
-        });
-        messages = loaded || {};
-    }
-    // Create immutable translator snapshot
-    return createTranslator({ config, locale, messages, handlers, plugins });
-}
-
-export { initTranslator };

package/dist/types/export/svelte-kit/server/index.d.ts

@@ -1 +0,0 @@
-export { createIntorHandler, intor } from "../../../src/adapters/svelte-kit/server";

package/dist/types/src/adapters/svelte-kit/server/index.d.ts

@@ -1,2 +0,0 @@
-export { createIntorHandler } from "./create-intor-handler";
-export { intor } from "./intor";

package/dist/types/src/adapters/svelte-kit/server/intor.d.ts

@@ -1,20 +0,0 @@
-import type { IntorResolvedConfig } from "../../../config";
-import type { MessagesReaders, RuntimeFetch } from "../../../core";
-import type { Locale, LocaleMessages } from "intor-translator";
-import { type IntorValue as IntorValueCore } from "../../../server";
-interface IntorValue extends Pick<IntorValueCore, "config"> {
-    locale: Locale;
-    messages: Readonly<LocaleMessages>;
-}
-/**
- * Initializes Intor for the current execution context.
- *
- * - Uses the locale resolved by the SvelteKit request lifecycle.
- * - Permits cache writes during server execution.
- * @platform SvelteKit
- */
-export declare function intor(config: IntorResolvedConfig, locale: Locale, fetch: RuntimeFetch, options?: {
-    readers?: MessagesReaders;
-    allowCacheWrite?: boolean;
-}): Promise<IntorValue>;
-export {};