@genrwork/laravel-i18next 0.1.0

package/dist/vite.cjs

@@ -0,0 +1,315 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var fs = require('fs');
+var path = require('path');
+var vite = require('vite');
+var phpArrayReader = require('php-array-reader');
+
+/**
+ * Normalize the separators of a directory name and ensure a trailing separator.
+ *
+ * @param rawDirname
+ */ function dirnameSanitize(rawDirname) {
+    return rawDirname.replace(/[\\/]+/g, path.sep).replace(/[\\/]+$/, '') + path.sep;
+}
+
+/**
+ * Whether `dirname` contains at least one `.php` file, at any depth.
+ *
+ * @param dirname
+ */ function hasPhpFile(dirname) {
+    return fs.readdirSync(dirname, {
+        withFileTypes: true
+    }).some((entry)=>{
+        if (entry.isDirectory()) return hasPhpFile(path.join(dirname, entry.name));
+        return entry.isFile() && entry.name.endsWith('.php');
+    });
+}
+var locale = {
+    /**
+     * Locales having a `lang/{locale}/` directory containing PHP files,
+     * however deep -- a locale whose PHP all lives in a nested namespace
+     * subdirectory still counts.
+     *
+     * @param dirname
+     */ getPhpLocale: (dirname)=>{
+        const sanitizedDirname = dirnameSanitize(dirname);
+        if (!fs.existsSync(sanitizedDirname)) {
+            return [];
+        }
+        return fs.readdirSync(sanitizedDirname).filter((folder)=>{
+            const fullPath = path.join(sanitizedDirname, folder);
+            return fs.statSync(fullPath).isDirectory();
+        }).filter((folder)=>hasPhpFile(path.join(sanitizedDirname, folder))).sort();
+    }
+};
+
+/**
+ * Convert every `lang/{locale}/{namespace}.php` file into a sibling
+ * `lang/{locale}/{namespace}.json` file, one per PHP file, so each PHP file
+ * becomes its own i18next namespace instead of being merged with the others.
+ * A PHP file may sit at any depth under the locale directory --
+ * `lang/{locale}/{ns1}/{ns2}.php` and deeper -- and gets its sibling `.json`
+ * written at that same nested path; the resulting namespace name itself is
+ * inferred later, from the generated file's path, by `src/utils/recognizer.ts`.
+ *
+ * A source meant to hold hand-written JSON (e.g. a frontend-only catalog)
+ * should never also hold PHP files of the same name -- this directory is a
+ * PHP source, so its sibling `.json` is always regenerated, overwriting
+ * whatever was there before (including a leftover from a previous, uncleaned
+ * run). Keep hand-written translations in their own source directory.
+ *
+ * @param dirname
+ */ function parser(dirname) {
+    const sanitizedDirname = dirnameSanitize(dirname);
+    if (!fs.existsSync(sanitizedDirname)) {
+        return [];
+    }
+    return fs.readdirSync(sanitizedDirname).filter((locale)=>fs.statSync(path.join(sanitizedDirname, locale)).isDirectory()).sort().flatMap((locale)=>generateNamespaceFiles(path.join(sanitizedDirname, locale)));
+}
+/**
+ * Convert every `.php` file found anywhere under a locale directory into a
+ * sibling `.json` file at the same relative path, depth-first and
+ * alphabetically within each directory level.
+ *
+ * @param localeDirname
+ */ function generateNamespaceFiles(localeDirname) {
+    return walkPhpFiles(localeDirname).sort().map((phpPath)=>{
+        const content = fs.readFileSync(phpPath, 'utf-8');
+        const translations = convertToDottedKey(phpArrayReader.fromString(content));
+        const outputPath = phpPath.replace(/\.php$/, '.json');
+        fs.writeFileSync(outputPath, JSON.stringify(translations));
+        return {
+            basename: path.basename(outputPath),
+            path: outputPath
+        };
+    });
+}
+/**
+ * Every `.php` file under `dirname`, at any depth, as absolute paths.
+ *
+ * @param dirname
+ */ function walkPhpFiles(dirname) {
+    return fs.readdirSync(dirname, {
+        withFileTypes: true
+    }).flatMap((entry)=>{
+        const entryPath = path.join(dirname, entry.name);
+        if (entry.isDirectory()) return walkPhpFiles(entryPath);
+        return entry.isFile() && entry.name.endsWith('.php') ? [
+            entryPath
+        ] : [];
+    });
+}
+/**
+ * Flatten nested translations into dotted keys, e.g. `sub_level1.sub_level2.text`.
+ *
+ * @param source
+ * @param target
+ * @param keys
+ */ function convertToDottedKey(source, target = {}, keys = []) {
+    Object.entries(source).forEach(([key, value])=>{
+        const newPrefix = [
+            ...keys,
+            key
+        ];
+        if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+            convertToDottedKey(value, target, newPrefix);
+        } else {
+            target[newPrefix.join('.')] = value;
+        }
+    });
+    return target;
+}
+
+function isDirectory(dir) {
+    return fs.existsSync(dir) && fs.statSync(dir).isDirectory();
+}
+function countWildcardSegments(normalizedPattern) {
+    return normalizedPattern.split('/').filter((segment)=>segment === '*').length;
+}
+/**
+ * Every directory an ordered source `pattern` currently expands to, relative
+ * to `root`. A pattern with no `*` is a single literal directory (existing or
+ * not -- callers decide what an absent literal directory means). A pattern
+ * with exactly one `*` segment (e.g. `Modules/*\/lang`) is expanded against
+ * the filesystem: every existing subdirectory of the prefix before the `*`,
+ * with the suffix after it appended, kept only when the full path also
+ * exists, sorted. Two or more `*` segments throw -- unsupported.
+ *
+ * @param pattern
+ * @param root
+ */ function expandDirs(pattern, root) {
+    const normalized = pattern.replace(/[\\/]+/g, '/');
+    if (countWildcardSegments(normalized) > 1) {
+        throw new Error(`laravel-i18next: a source pattern may contain at most one "*" segment, got "${pattern}".`);
+    }
+    const segments = normalized.split('/').filter(Boolean);
+    const wildcardIndex = segments.indexOf('*');
+    if (wildcardIndex === -1) {
+        const dir = path.resolve(root, normalized);
+        return isDirectory(dir) ? [
+            dir
+        ] : [];
+    }
+    const prefix = path.resolve(root, segments.slice(0, wildcardIndex).join('/'));
+    const suffix = segments.slice(wildcardIndex + 1);
+    if (!isDirectory(prefix)) return [];
+    return fs.readdirSync(prefix, {
+        withFileTypes: true
+    }).filter((entry)=>entry.isDirectory()).map((entry)=>path.join(prefix, entry.name, ...suffix)).filter(isDirectory).sort();
+}
+/**
+ * The root-relative glob `import.meta.glob()` needs for a source pattern.
+ * Globs inside a virtual module have no containing file to be relative to,
+ * so this is always root-relative (a leading `/`). A `*` segment in the
+ * pattern passes through `path.resolve`/`path.relative`/`normalizePath`
+ * completely untouched -- none of them treat it specially -- which is why
+ * the emitted glob needs no separate wildcard handling: `Modules/*\/lang`
+ * becomes `/Modules/*\/lang/**\/*.json` and `import.meta.glob()` expands the
+ * `*` itself, natively, at both dev and build time.
+ *
+ * @param pattern
+ * @param root
+ */ function toGlob(pattern, root) {
+    const relative = vite.normalizePath(path.relative(root, path.resolve(root, pattern.replace(/[\\/]+/g, '/'))));
+    return `/${relative}/**/*.json`;
+}
+/**
+ * Whether `file` sits under one of `dirnames` (any depth) -- used to decide
+ * whether a changed file belongs to any configured source at all.
+ *
+ * @param file
+ * @param dirnames
+ */ function isUnderAnySource(file, dirnames) {
+    const normalizedFile = vite.normalizePath(file);
+    return dirnames.some((dir)=>normalizedFile.startsWith(`${vite.normalizePath(dir)}/`));
+}
+
+/**
+ * Language files, one namespace per language file: loaded eagerly by server
+ * code (SSR), so it renders translated, and lazily by client code. The
+ * default export is an ARRAY, one entry per configured source in `sources`,
+ * highest priority first (see `LocaleFileSources` in `src/interfaces/options.ts`).
+ */ const FILES_MODULE_ID = 'virtual:laravel-i18next/files';
+const RESOLVED_FILES_MODULE_ID = `\0${FILES_MODULE_ID}`;
+/**
+ * Makes Laravel PHP translations available to i18next by generating a sibling
+ * `.json` file next to each `.php` file, across one or more ordered sources.
+ */ function i18n(config) {
+    var _a;
+    const logger = vite.createLogger('info', {
+        prefix: '[laravel-i18next]'
+    });
+    const sourcePatterns = (_a = config === null || config === void 0 ? void 0 : config.sources) !== null && _a !== void 0 ? _a : [
+        'lang'
+    ];
+    let root = process.cwd();
+    let generated = [];
+    let exitHandlersBound = false;
+    function clean() {
+        generated.forEach((file)=>fs.existsSync(file.path) && fs.unlinkSync(file.path));
+        generated = [];
+    }
+    /**
+     * (Re)generate every source's sibling `.json` files. Run once up front
+     * (`config()`) and again whenever a `.php` file changes (`hotUpdate` /
+     * `handleHotUpdate`).
+     */ function parseAll() {
+        let anyPhp = false;
+        generated = sourcePatterns.flatMap((pattern)=>{
+            const dirnames = expandDirs(pattern, root);
+            // A literal (wildcard-free) source that does not exist is very likely
+            // a setup mistake -- a wrong path, or (Laravel 9+) `php artisan
+            // lang:publish` was never run.
+            // A wildcard source matching nothing (no modules yet) is normal, so it
+            // stays silent.
+            if (dirnames.length === 0 && !pattern.includes('*')) {
+                logger.error(`Source "${pattern}" does not exist. Check the "sources" option (Laravel 9+ keeps language files in "lang", older versions in "resources/lang"), or on Laravel 9+ publish them with \`php artisan lang:publish\`.`, {
+                    timestamp: true
+                });
+                logger.error('For more information please visit: https://laravel.com/docs/10.x/localization#publishing-the-language-files', {
+                    timestamp: true
+                });
+            }
+            return dirnames.flatMap((dirname)=>{
+                if (locale.getPhpLocale(dirname).length > 0) anyPhp = true;
+                return parser(dirname);
+            });
+        });
+        if (!anyPhp) {
+            logger.info('No source contains PHP translation files.', {
+                timestamp: true
+            });
+            logger.info('For more information please visit: https://laravel.com/docs/10.x/localization#introduction', {
+                timestamp: true
+            });
+        }
+        return generated;
+    }
+    function isTranslationSource(file) {
+        return sourcePatterns.some((pattern)=>isUnderAnySource(file, expandDirs(pattern, root)));
+    }
+    return {
+        name: 'i18n',
+        enforce: 'post',
+        configResolved (resolvedConfig) {
+            root = resolvedConfig.root;
+        },
+        resolveId: {
+            order: 'pre',
+            handler (id) {
+                return id === FILES_MODULE_ID ? RESOLVED_FILES_MODULE_ID : undefined;
+            }
+        },
+        load (id, options) {
+            if (id !== RESOLVED_FILES_MODULE_ID) return undefined;
+            // Globs of virtual modules must be relative to the root. Recursive, so
+            // each also matches namespaces nested any number of levels deep.
+            const entries = sourcePatterns.map((pattern)=>JSON.stringify(toGlob(pattern, root))).map((pattern)=>(options === null || options === void 0 ? void 0 : options.ssr) ? `import.meta.glob(${pattern}, { eager: true })` : `import.meta.glob(${pattern})`).join(', ');
+            return `export default [${entries}];`;
+        },
+        config (userConfig) {
+            var _a;
+            // `config()` runs before `configResolved()`, so `root` is not yet the
+            // fully resolved one here -- close enough for source expansion, and
+            // `configResolved` overwrites it before `load()` ever runs.
+            root = path.resolve((_a = userConfig === null || userConfig === void 0 ? void 0 : userConfig.root) !== null && _a !== void 0 ? _a : process.cwd());
+            parseAll();
+        },
+        buildEnd: clean,
+        // `hotUpdate` (Vite 6+) is the modern hook; `handleHotUpdate` is kept for
+        // the `vite >= 5` peer range and is ignored by Vite whenever `hotUpdate`
+        // is also defined. Neither hook needs to invalidate the virtual module
+        // for an ADDED or DELETED json file, nor for a CHANGED one -- Vite's own
+        // `import.meta.glob` HMR already does that, virtual ids included. What
+        // is not free: a brand-new `.php` file has no sibling `.json` yet for
+        // that glob to notice, so it must be parsed here first.
+        hotUpdate (options) {
+            var _a;
+            if (!isTranslationSource(options.file)) return undefined;
+            if (options.file.endsWith('.php')) parseAll();
+            const filesModule = this.environment.moduleGraph.getModuleById(RESOLVED_FILES_MODULE_ID);
+            if (!filesModule) return undefined;
+            return [
+                ...(_a = this.environment.moduleGraph.getModulesByFile(options.file)) !== null && _a !== void 0 ? _a : [],
+                filesModule
+            ];
+        },
+        handleHotUpdate (ctx) {
+            if (isTranslationSource(ctx.file) && ctx.file.endsWith('.php')) parseAll();
+        },
+        configureServer () {
+            if (exitHandlersBound) return;
+            process.on('exit', clean);
+            process.on('SIGINT', process.exit);
+            process.on('SIGTERM', process.exit);
+            process.on('SIGHUP', process.exit);
+            exitHandlersBound = true;
+        }
+    };
+}
+
+exports.FILES_MODULE_ID = FILES_MODULE_ID;
+exports.default = i18n;

package/dist/vite.mjs

@@ -0,0 +1,310 @@
+import fs from 'fs';
+import path from 'path';
+import { normalizePath, createLogger } from 'vite';
+import { fromString } from 'php-array-reader';
+
+/**
+ * Normalize the separators of a directory name and ensure a trailing separator.
+ *
+ * @param rawDirname
+ */ function dirnameSanitize(rawDirname) {
+    return rawDirname.replace(/[\\/]+/g, path.sep).replace(/[\\/]+$/, '') + path.sep;
+}
+
+/**
+ * Whether `dirname` contains at least one `.php` file, at any depth.
+ *
+ * @param dirname
+ */ function hasPhpFile(dirname) {
+    return fs.readdirSync(dirname, {
+        withFileTypes: true
+    }).some((entry)=>{
+        if (entry.isDirectory()) return hasPhpFile(path.join(dirname, entry.name));
+        return entry.isFile() && entry.name.endsWith('.php');
+    });
+}
+var locale = {
+    /**
+     * Locales having a `lang/{locale}/` directory containing PHP files,
+     * however deep -- a locale whose PHP all lives in a nested namespace
+     * subdirectory still counts.
+     *
+     * @param dirname
+     */ getPhpLocale: (dirname)=>{
+        const sanitizedDirname = dirnameSanitize(dirname);
+        if (!fs.existsSync(sanitizedDirname)) {
+            return [];
+        }
+        return fs.readdirSync(sanitizedDirname).filter((folder)=>{
+            const fullPath = path.join(sanitizedDirname, folder);
+            return fs.statSync(fullPath).isDirectory();
+        }).filter((folder)=>hasPhpFile(path.join(sanitizedDirname, folder))).sort();
+    }
+};
+
+/**
+ * Convert every `lang/{locale}/{namespace}.php` file into a sibling
+ * `lang/{locale}/{namespace}.json` file, one per PHP file, so each PHP file
+ * becomes its own i18next namespace instead of being merged with the others.
+ * A PHP file may sit at any depth under the locale directory --
+ * `lang/{locale}/{ns1}/{ns2}.php` and deeper -- and gets its sibling `.json`
+ * written at that same nested path; the resulting namespace name itself is
+ * inferred later, from the generated file's path, by `src/utils/recognizer.ts`.
+ *
+ * A source meant to hold hand-written JSON (e.g. a frontend-only catalog)
+ * should never also hold PHP files of the same name -- this directory is a
+ * PHP source, so its sibling `.json` is always regenerated, overwriting
+ * whatever was there before (including a leftover from a previous, uncleaned
+ * run). Keep hand-written translations in their own source directory.
+ *
+ * @param dirname
+ */ function parser(dirname) {
+    const sanitizedDirname = dirnameSanitize(dirname);
+    if (!fs.existsSync(sanitizedDirname)) {
+        return [];
+    }
+    return fs.readdirSync(sanitizedDirname).filter((locale)=>fs.statSync(path.join(sanitizedDirname, locale)).isDirectory()).sort().flatMap((locale)=>generateNamespaceFiles(path.join(sanitizedDirname, locale)));
+}
+/**
+ * Convert every `.php` file found anywhere under a locale directory into a
+ * sibling `.json` file at the same relative path, depth-first and
+ * alphabetically within each directory level.
+ *
+ * @param localeDirname
+ */ function generateNamespaceFiles(localeDirname) {
+    return walkPhpFiles(localeDirname).sort().map((phpPath)=>{
+        const content = fs.readFileSync(phpPath, 'utf-8');
+        const translations = convertToDottedKey(fromString(content));
+        const outputPath = phpPath.replace(/\.php$/, '.json');
+        fs.writeFileSync(outputPath, JSON.stringify(translations));
+        return {
+            basename: path.basename(outputPath),
+            path: outputPath
+        };
+    });
+}
+/**
+ * Every `.php` file under `dirname`, at any depth, as absolute paths.
+ *
+ * @param dirname
+ */ function walkPhpFiles(dirname) {
+    return fs.readdirSync(dirname, {
+        withFileTypes: true
+    }).flatMap((entry)=>{
+        const entryPath = path.join(dirname, entry.name);
+        if (entry.isDirectory()) return walkPhpFiles(entryPath);
+        return entry.isFile() && entry.name.endsWith('.php') ? [
+            entryPath
+        ] : [];
+    });
+}
+/**
+ * Flatten nested translations into dotted keys, e.g. `sub_level1.sub_level2.text`.
+ *
+ * @param source
+ * @param target
+ * @param keys
+ */ function convertToDottedKey(source, target = {}, keys = []) {
+    Object.entries(source).forEach(([key, value])=>{
+        const newPrefix = [
+            ...keys,
+            key
+        ];
+        if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+            convertToDottedKey(value, target, newPrefix);
+        } else {
+            target[newPrefix.join('.')] = value;
+        }
+    });
+    return target;
+}
+
+function isDirectory(dir) {
+    return fs.existsSync(dir) && fs.statSync(dir).isDirectory();
+}
+function countWildcardSegments(normalizedPattern) {
+    return normalizedPattern.split('/').filter((segment)=>segment === '*').length;
+}
+/**
+ * Every directory an ordered source `pattern` currently expands to, relative
+ * to `root`. A pattern with no `*` is a single literal directory (existing or
+ * not -- callers decide what an absent literal directory means). A pattern
+ * with exactly one `*` segment (e.g. `Modules/*\/lang`) is expanded against
+ * the filesystem: every existing subdirectory of the prefix before the `*`,
+ * with the suffix after it appended, kept only when the full path also
+ * exists, sorted. Two or more `*` segments throw -- unsupported.
+ *
+ * @param pattern
+ * @param root
+ */ function expandDirs(pattern, root) {
+    const normalized = pattern.replace(/[\\/]+/g, '/');
+    if (countWildcardSegments(normalized) > 1) {
+        throw new Error(`laravel-i18next: a source pattern may contain at most one "*" segment, got "${pattern}".`);
+    }
+    const segments = normalized.split('/').filter(Boolean);
+    const wildcardIndex = segments.indexOf('*');
+    if (wildcardIndex === -1) {
+        const dir = path.resolve(root, normalized);
+        return isDirectory(dir) ? [
+            dir
+        ] : [];
+    }
+    const prefix = path.resolve(root, segments.slice(0, wildcardIndex).join('/'));
+    const suffix = segments.slice(wildcardIndex + 1);
+    if (!isDirectory(prefix)) return [];
+    return fs.readdirSync(prefix, {
+        withFileTypes: true
+    }).filter((entry)=>entry.isDirectory()).map((entry)=>path.join(prefix, entry.name, ...suffix)).filter(isDirectory).sort();
+}
+/**
+ * The root-relative glob `import.meta.glob()` needs for a source pattern.
+ * Globs inside a virtual module have no containing file to be relative to,
+ * so this is always root-relative (a leading `/`). A `*` segment in the
+ * pattern passes through `path.resolve`/`path.relative`/`normalizePath`
+ * completely untouched -- none of them treat it specially -- which is why
+ * the emitted glob needs no separate wildcard handling: `Modules/*\/lang`
+ * becomes `/Modules/*\/lang/**\/*.json` and `import.meta.glob()` expands the
+ * `*` itself, natively, at both dev and build time.
+ *
+ * @param pattern
+ * @param root
+ */ function toGlob(pattern, root) {
+    const relative = normalizePath(path.relative(root, path.resolve(root, pattern.replace(/[\\/]+/g, '/'))));
+    return `/${relative}/**/*.json`;
+}
+/**
+ * Whether `file` sits under one of `dirnames` (any depth) -- used to decide
+ * whether a changed file belongs to any configured source at all.
+ *
+ * @param file
+ * @param dirnames
+ */ function isUnderAnySource(file, dirnames) {
+    const normalizedFile = normalizePath(file);
+    return dirnames.some((dir)=>normalizedFile.startsWith(`${normalizePath(dir)}/`));
+}
+
+/**
+ * Language files, one namespace per language file: loaded eagerly by server
+ * code (SSR), so it renders translated, and lazily by client code. The
+ * default export is an ARRAY, one entry per configured source in `sources`,
+ * highest priority first (see `LocaleFileSources` in `src/interfaces/options.ts`).
+ */ const FILES_MODULE_ID = 'virtual:laravel-i18next/files';
+const RESOLVED_FILES_MODULE_ID = `\0${FILES_MODULE_ID}`;
+/**
+ * Makes Laravel PHP translations available to i18next by generating a sibling
+ * `.json` file next to each `.php` file, across one or more ordered sources.
+ */ function i18n(config) {
+    var _a;
+    const logger = createLogger('info', {
+        prefix: '[laravel-i18next]'
+    });
+    const sourcePatterns = (_a = config === null || config === void 0 ? void 0 : config.sources) !== null && _a !== void 0 ? _a : [
+        'lang'
+    ];
+    let root = process.cwd();
+    let generated = [];
+    let exitHandlersBound = false;
+    function clean() {
+        generated.forEach((file)=>fs.existsSync(file.path) && fs.unlinkSync(file.path));
+        generated = [];
+    }
+    /**
+     * (Re)generate every source's sibling `.json` files. Run once up front
+     * (`config()`) and again whenever a `.php` file changes (`hotUpdate` /
+     * `handleHotUpdate`).
+     */ function parseAll() {
+        let anyPhp = false;
+        generated = sourcePatterns.flatMap((pattern)=>{
+            const dirnames = expandDirs(pattern, root);
+            // A literal (wildcard-free) source that does not exist is very likely
+            // a setup mistake -- a wrong path, or (Laravel 9+) `php artisan
+            // lang:publish` was never run.
+            // A wildcard source matching nothing (no modules yet) is normal, so it
+            // stays silent.
+            if (dirnames.length === 0 && !pattern.includes('*')) {
+                logger.error(`Source "${pattern}" does not exist. Check the "sources" option (Laravel 9+ keeps language files in "lang", older versions in "resources/lang"), or on Laravel 9+ publish them with \`php artisan lang:publish\`.`, {
+                    timestamp: true
+                });
+                logger.error('For more information please visit: https://laravel.com/docs/10.x/localization#publishing-the-language-files', {
+                    timestamp: true
+                });
+            }
+            return dirnames.flatMap((dirname)=>{
+                if (locale.getPhpLocale(dirname).length > 0) anyPhp = true;
+                return parser(dirname);
+            });
+        });
+        if (!anyPhp) {
+            logger.info('No source contains PHP translation files.', {
+                timestamp: true
+            });
+            logger.info('For more information please visit: https://laravel.com/docs/10.x/localization#introduction', {
+                timestamp: true
+            });
+        }
+        return generated;
+    }
+    function isTranslationSource(file) {
+        return sourcePatterns.some((pattern)=>isUnderAnySource(file, expandDirs(pattern, root)));
+    }
+    return {
+        name: 'i18n',
+        enforce: 'post',
+        configResolved (resolvedConfig) {
+            root = resolvedConfig.root;
+        },
+        resolveId: {
+            order: 'pre',
+            handler (id) {
+                return id === FILES_MODULE_ID ? RESOLVED_FILES_MODULE_ID : undefined;
+            }
+        },
+        load (id, options) {
+            if (id !== RESOLVED_FILES_MODULE_ID) return undefined;
+            // Globs of virtual modules must be relative to the root. Recursive, so
+            // each also matches namespaces nested any number of levels deep.
+            const entries = sourcePatterns.map((pattern)=>JSON.stringify(toGlob(pattern, root))).map((pattern)=>(options === null || options === void 0 ? void 0 : options.ssr) ? `import.meta.glob(${pattern}, { eager: true })` : `import.meta.glob(${pattern})`).join(', ');
+            return `export default [${entries}];`;
+        },
+        config (userConfig) {
+            var _a;
+            // `config()` runs before `configResolved()`, so `root` is not yet the
+            // fully resolved one here -- close enough for source expansion, and
+            // `configResolved` overwrites it before `load()` ever runs.
+            root = path.resolve((_a = userConfig === null || userConfig === void 0 ? void 0 : userConfig.root) !== null && _a !== void 0 ? _a : process.cwd());
+            parseAll();
+        },
+        buildEnd: clean,
+        // `hotUpdate` (Vite 6+) is the modern hook; `handleHotUpdate` is kept for
+        // the `vite >= 5` peer range and is ignored by Vite whenever `hotUpdate`
+        // is also defined. Neither hook needs to invalidate the virtual module
+        // for an ADDED or DELETED json file, nor for a CHANGED one -- Vite's own
+        // `import.meta.glob` HMR already does that, virtual ids included. What
+        // is not free: a brand-new `.php` file has no sibling `.json` yet for
+        // that glob to notice, so it must be parsed here first.
+        hotUpdate (options) {
+            var _a;
+            if (!isTranslationSource(options.file)) return undefined;
+            if (options.file.endsWith('.php')) parseAll();
+            const filesModule = this.environment.moduleGraph.getModuleById(RESOLVED_FILES_MODULE_ID);
+            if (!filesModule) return undefined;
+            return [
+                ...(_a = this.environment.moduleGraph.getModulesByFile(options.file)) !== null && _a !== void 0 ? _a : [],
+                filesModule
+            ];
+        },
+        handleHotUpdate (ctx) {
+            if (isTranslationSource(ctx.file) && ctx.file.endsWith('.php')) parseAll();
+        },
+        configureServer () {
+            if (exitHandlersBound) return;
+            process.on('exit', clean);
+            process.on('SIGINT', process.exit);
+            process.on('SIGTERM', process.exit);
+            process.on('SIGHUP', process.exit);
+            exitHandlersBound = true;
+        }
+    };
+}
+
+export { FILES_MODULE_ID, i18n as default };

package/dist/vue.cjs

@@ -0,0 +1,39 @@
+'use strict';
+
+var I18NextVue = require('i18next-vue');
+var createI18n = require('./shared/create-i18n-WsDK4Z8L.cjs');
+require('i18next');
+
+/**
+ * Vue plugin providing an i18next instance translating Laravel language files
+ * to `i18next-vue`'s `useTranslation()` composable and `$t`/`$i18next`.
+ *
+ * Every app instance owns its own i18next instance, so concurrent SSR requests
+ * do not share a language.
+ *
+ * ```ts
+ * import { createApp } from 'vue';
+ * import { laravelVueI18n } from '@genrwork/laravel-i18next/vue';
+ *
+ * createApp(App)
+ *   .use(laravelVueI18n({ locale: 'uk', fallbackLocale: 'en', files: import.meta.glob('/lang/**\/*.json') }))
+ *   .mount('#app');
+ * ```
+ */ function laravelVueI18n(options) {
+    return {
+        install (app) {
+            const i18next = createI18n.createI18n(options);
+            // Lives for the app's lifetime, so it is never unsubscribed.
+            createI18n.syncDocumentLang(i18next);
+            app.use(I18NextVue, {
+                i18next
+            });
+        }
+    };
+}
+
+Object.defineProperty(exports, "useTranslation", {
+    enumerable: true,
+    get: function () { return I18NextVue.useTranslation; }
+});
+exports.laravelVueI18n = laravelVueI18n;