@genrwork/laravel-i18next 0.1.0

package/dist/svelte.cjs

@@ -0,0 +1,77 @@
+'use strict';
+
+var svelte = require('svelte');
+var store = require('svelte/store');
+var createI18n = require('./shared/create-i18n-WsDK4Z8L.cjs');
+require('i18next');
+
+const CONTEXT_KEY = 'laravel-i18next';
+/**
+ * Create an i18next instance translating Laravel language files, and make it
+ * available to `useTranslation()` in child components.
+ *
+ * Every call creates its own instance, so concurrent SSR requests do not share
+ * a language. Must be called during component initialization (top level of `<script>`).
+ *
+ * ```svelte
+ * <script>
+ *   import { setLaravelI18nContext } from '@genrwork/laravel-i18next/svelte';
+ *
+ *   setLaravelI18nContext({
+ *     locale: data.locale,
+ *     fallbackLocale: 'en',
+ *     files: import.meta.glob('/lang/**\/*.json'),
+ *   });
+ * </script>
+ * ```
+ */ function setLaravelI18nContext(options) {
+    const i18next = createI18n.createI18n(options);
+    const unsubscribe = createI18n.syncDocumentLang(i18next);
+    svelte.onDestroy(unsubscribe);
+    svelte.setContext(CONTEXT_KEY, i18next);
+    return i18next;
+}
+function getI18nextFromContext() {
+    if (!svelte.hasContext(CONTEXT_KEY)) {
+        throw new Error('No Laravel i18next instance found in context. Call setLaravelI18nContext() in a parent component.');
+    }
+    return svelte.getContext(CONTEXT_KEY);
+}
+/**
+ * A reactive `t()` function and `ready` flag for the given namespace, bound to
+ * the i18next instance set with `setLaravelI18nContext()`.
+ *
+ * ```svelte
+ * <script>
+ *   import { useTranslation } from '@genrwork/laravel-i18next/svelte';
+ *
+ *   const { t } = useTranslation('auth');
+ * </script>
+ *
+ * <p>{$t('failed')}</p>
+ * ```
+ */ function useTranslation(namespace, i18nextInstance) {
+    const instance = i18nextInstance !== null && i18nextInstance !== void 0 ? i18nextInstance : getI18nextFromContext();
+    const revision = store.writable(0);
+    const bump = ()=>revision.update((n)=>n + 1);
+    instance.on('languageChanged', bump);
+    instance.on('loaded', bump);
+    instance.on('added', bump);
+    svelte.onDestroy(()=>{
+        instance.off('languageChanged', bump);
+        instance.off('loaded', bump);
+        instance.off('added', bump);
+    });
+    const t = store.derived(revision, ()=>instance.getFixedT(null, namespace !== null && namespace !== void 0 ? namespace : null));
+    const ready = store.derived(revision, ()=>instance.isInitialized && (!namespace || instance.hasLoadedNamespace(namespace)));
+    const language = store.derived(revision, ()=>instance.language);
+    return {
+        t,
+        ready,
+        language,
+        i18next: instance
+    };
+}
+
+exports.setLaravelI18nContext = setLaravelI18nContext;
+exports.useTranslation = useTranslation;

package/dist/svelte.mjs

@@ -0,0 +1,74 @@
+import { onDestroy, setContext, hasContext, getContext } from 'svelte';
+import { writable, derived } from 'svelte/store';
+import { c as createI18n, s as syncDocumentLang } from './shared/create-i18n-BSEwKsCX.mjs';
+import 'i18next';
+
+const CONTEXT_KEY = 'laravel-i18next';
+/**
+ * Create an i18next instance translating Laravel language files, and make it
+ * available to `useTranslation()` in child components.
+ *
+ * Every call creates its own instance, so concurrent SSR requests do not share
+ * a language. Must be called during component initialization (top level of `<script>`).
+ *
+ * ```svelte
+ * <script>
+ *   import { setLaravelI18nContext } from '@genrwork/laravel-i18next/svelte';
+ *
+ *   setLaravelI18nContext({
+ *     locale: data.locale,
+ *     fallbackLocale: 'en',
+ *     files: import.meta.glob('/lang/**\/*.json'),
+ *   });
+ * </script>
+ * ```
+ */ function setLaravelI18nContext(options) {
+    const i18next = createI18n(options);
+    const unsubscribe = syncDocumentLang(i18next);
+    onDestroy(unsubscribe);
+    setContext(CONTEXT_KEY, i18next);
+    return i18next;
+}
+function getI18nextFromContext() {
+    if (!hasContext(CONTEXT_KEY)) {
+        throw new Error('No Laravel i18next instance found in context. Call setLaravelI18nContext() in a parent component.');
+    }
+    return getContext(CONTEXT_KEY);
+}
+/**
+ * A reactive `t()` function and `ready` flag for the given namespace, bound to
+ * the i18next instance set with `setLaravelI18nContext()`.
+ *
+ * ```svelte
+ * <script>
+ *   import { useTranslation } from '@genrwork/laravel-i18next/svelte';
+ *
+ *   const { t } = useTranslation('auth');
+ * </script>
+ *
+ * <p>{$t('failed')}</p>
+ * ```
+ */ function useTranslation(namespace, i18nextInstance) {
+    const instance = i18nextInstance !== null && i18nextInstance !== void 0 ? i18nextInstance : getI18nextFromContext();
+    const revision = writable(0);
+    const bump = ()=>revision.update((n)=>n + 1);
+    instance.on('languageChanged', bump);
+    instance.on('loaded', bump);
+    instance.on('added', bump);
+    onDestroy(()=>{
+        instance.off('languageChanged', bump);
+        instance.off('loaded', bump);
+        instance.off('added', bump);
+    });
+    const t = derived(revision, ()=>instance.getFixedT(null, namespace !== null && namespace !== void 0 ? namespace : null));
+    const ready = derived(revision, ()=>instance.isInitialized && (!namespace || instance.hasLoadedNamespace(namespace)));
+    const language = derived(revision, ()=>instance.language);
+    return {
+        t,
+        ready,
+        language,
+        i18next: instance
+    };
+}
+
+export { setLaravelI18nContext, useTranslation };

package/dist/types/backend.d.ts

@@ -0,0 +1,29 @@
+import type { BackendModule, ReadCallback } from 'i18next';
+import type LaravelBackendOptions from './interfaces/options';
+/**
+ * i18next backend loading Laravel language files as separate namespaces from
+ * one or more sources, highest priority first: the default namespace from
+ * `{source}/{locale}.json`, and one namespace per PHP file from
+ * `{source}/{locale}/{namespace}.json` (generated by the Vite plugin from
+ * `{namespace}.php`, or hand-written) -- a namespace may also nest to any
+ * depth, see `src/utils/recognizer.ts`.
+ *
+ * When several sources have a file for the same `(locale, namespace)`, they
+ * are merged per key: a higher-priority source's key overrides a
+ * lower-priority one, but a key present only in a lower-priority source still
+ * resolves. This is what lets a namespace migrate from PHP to hand-written
+ * JSON one string at a time.
+ *
+ * Eager files are read synchronously, lazy files asynchronously -- and the
+ * whole read stays synchronous as long as every candidate for the pair is
+ * eager, even when several sources contribute, which SSR depends on
+ * (`initAsync: false` + `preload`). A (locale, namespace) pair without a
+ * matching file in any source gets no resources.
+ */
+export default class LaravelBackend implements BackendModule<LaravelBackendOptions> {
+    static type: "backend";
+    type: "backend";
+    private files;
+    init(_services: unknown, backendOptions?: Partial<LaravelBackendOptions>): void;
+    read(language: string, namespace: string, callback: ReadCallback): void;
+}

package/dist/types/contrib/get-plural-index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Get the index to use for pluralization.
+ * The plural rules are derived from code of the Zend Framework.
+ *
+ * @category    Zend
+ * @package     Zend_Locale
+ * @public      https://github.com/zendframework/zf1/blob/master/library/Zend/Translate/Plural.php
+ * @copyright   2005-2015 Zend Technologies USA Inc. http://www.zend.com
+ * @license     http://framework.zend.com/license     New BSD License
+ *
+ * @param  {String}  locale
+ * @param  {Number}  number
+ * @return {Number}
+ */
+export declare function getPluralIndex(locale: string, number: number): 1 | 0 | 3 | 2 | 4 | 5;

package/dist/types/format.d.ts

@@ -0,0 +1,43 @@
+import type { i18n, TOptions } from 'i18next';
+/**
+ * i18next format plugin translating the way Laravel does:
+ *
+ * - flat keys (`auth.failed`, `Welcome, :name!`), no key or namespace separators;
+ * - `:name`, `:NAME` and `:Name` replacements instead of `{{name}}` interpolation and `$t()` nesting;
+ * - a numeric `count` selects the message with Laravel's `trans_choice()` rules
+ *   (`one|many`, `{0} none|[1,19] some|[20,*] many`) instead of `_one`/`_other` suffixed keys;
+ * - empty messages fall back to the next language.
+ */
+export default class LaravelFormat {
+    static type: "i18nFormat";
+    type: "i18nFormat";
+    /**
+     * Non-string translations (e.g. an empty PHP array) are returned as is.
+     */
+    handleAsObject: boolean;
+    private i18next?;
+    init(i18next: i18n): void;
+    getResource(language: string, namespace: string, key: string): any;
+    addLookupKeys(finalKeys: string[]): string[];
+    parse(message: unknown, options: TOptions, language: string, namespace: string, _key?: string, info?: {
+        resolved?: {
+            usedLng?: string;
+        };
+    }): unknown;
+    /**
+     * The language the message actually resolved in, so pluralization always
+     * matches the text being pluralized -- never merely a language that has
+     * translations for the namespace, which is not the same thing once several
+     * sources can contribute to one namespace (see LaravelBackend): a single
+     * unrelated key from a higher-priority source is enough to make
+     * `hasResourceBundle(language, namespace)` true for a namespace whose
+     * actual message still came from the fallback language.
+     *
+     * i18next passes the language the lookup succeeded at as `resolved.usedLng`
+     * in `parse()`'s 6th argument (`extendTranslation()` in i18next's own
+     * `translator.js`); prefer it. Older i18next in the `>=24` peer range that
+     * does not pass it falls back to a heuristic: the current language when it
+     * has translations for the namespace, else the fallback language.
+     */
+    private getPluralLocale;
+}

package/dist/types/index.d.ts

@@ -0,0 +1,7 @@
+import LaravelBackend from './backend';
+import LaravelFormat from './format';
+export { LaravelBackend, LaravelFormat };
+export { createI18n, documentLocale, syncDocumentLang } from './shared/create-i18n';
+export type { LaravelI18nOptions } from './shared/create-i18n';
+export type { default as LaravelBackendOptions, LocaleFiles, LocaleFileSources } from './interfaces/options';
+export type { default as ReplacementsInterface } from './interfaces/replacements';

package/dist/types/interfaces/locale-file.d.ts

@@ -0,0 +1,8 @@
+/**
+ * A resolved language file module.
+ */
+export default interface LocaleFileInterface {
+    default: {
+        [key: string]: string;
+    };
+}

package/dist/types/interfaces/options.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Language files as returned by `import.meta.glob('/lang/*.json')`,
+ * either lazy (loader functions) or eager (modules).
+ */
+export type LocaleFiles = Record<string, unknown> | Record<string, () => Promise<unknown>>;
+/**
+ * One or more `LocaleFiles` maps, highest priority first. A single map is a
+ * one-source project; an array layers several sources, resolving each key from
+ * the highest-priority source that has it (see `toSources()` in
+ * `src/utils/sources.ts`). The Vite plugin's `sources` option always produces
+ * an array, one entry per configured source, in the same order.
+ */
+export type LocaleFileSources = LocaleFiles | LocaleFiles[];
+/**
+ * Options of `LaravelBackend`, given as the `backend` option of i18next.
+ */
+export default interface LaravelBackendOptions {
+    files: LocaleFileSources;
+}

package/dist/types/interfaces/replacements.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Placeholder replacements, e.g. `{ name: 'Francisco' }` for `:name`.
+ */
+export default interface ReplacementsInterface {
+    [key: string]: string | number;
+}

package/dist/types/plugin/helper.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Normalize the separators of a directory name and ensure a trailing separator.
+ *
+ * @param rawDirname
+ */
+export declare function dirnameSanitize(rawDirname: string): string;

package/dist/types/plugin/locale.d.ts

@@ -0,0 +1,11 @@
+declare const _default: {
+    /**
+     * 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: string) => string[];
+};
+export default _default;

package/dist/types/plugin/parser.d.ts

@@ -0,0 +1,22 @@
+export interface GeneratedFile {
+    path: string;
+    basename: string;
+}
+/**
+ * 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
+ */
+export default function parser(dirname: string): GeneratedFile[];

package/dist/types/plugin/sources.d.ts

@@ -0,0 +1,53 @@
+/**
+ * One configured source, resolved against the project root.
+ */
+export interface ResolvedSource {
+    /** As configured, e.g. `'Modules/*\/lang'`. */
+    pattern: string;
+    /** Root-relative glob for `import.meta.glob()`, e.g. `'/Modules/*\/lang/**\/*.json'`. */
+    glob: string;
+    /** Every directory the pattern currently expands to, existing ones only, sorted. */
+    dirnames: string[];
+}
+/**
+ * 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
+ */
+export declare function expandDirs(pattern: string, root: string): string[];
+/**
+ * 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
+ */
+export declare function toGlob(pattern: string, root: string): string;
+/**
+ * Resolve every configured source pattern, in the given order.
+ *
+ * @param patterns
+ * @param root
+ */
+export declare function resolveSources(patterns: string[], root: string): ResolvedSource[];
+/**
+ * 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
+ */
+export declare function isUnderAnySource(file: string, dirnames: string[]): boolean;

package/dist/types/react/i18n-provider-props.d.ts

@@ -0,0 +1,23 @@
+import type { ReactNode } from 'react';
+import type { LocaleFileSources } from '../interfaces/options';
+/**
+ * Props of `<LaravelReactI18nProvider>`.
+ */
+export default interface I18nProviderProps {
+    children: ReactNode;
+    /**
+     * Language files: `virtual:laravel-i18next/files` (an ordered array, one
+     * entry per configured `sources`, highest priority first), or a single
+     * `import.meta.glob('/lang/**\/*.json')` (lazy) /
+     * `import.meta.glob('/lang/**\/*.json', { eager: true })` (eager).
+     */
+    files: LocaleFileSources;
+    /**
+     * Defaults to the `<html lang="">` attribute, or `en`.
+     */
+    locale?: string;
+    /**
+     * Defaults to the `<html lang="">` attribute, or `en`.
+     */
+    fallbackLocale?: string;
+}

package/dist/types/react/index.d.ts

@@ -0,0 +1,3 @@
+import LaravelReactI18nProvider from './provider';
+export { LaravelReactI18nProvider };
+export type { default as I18nProviderProps } from './i18n-provider-props';

package/dist/types/react/provider.d.ts

@@ -0,0 +1,10 @@
+import type I18nProviderProps from './i18n-provider-props';
+/**
+ * Provides an i18next instance translating Laravel language files to react-i18next.
+ *
+ * Every provider owns its instance, so concurrent SSR requests do not share a language.
+ * With eager files, every namespace is preloaded and translated on the first render.
+ * While a lazy namespace loads, the children suspend, which keeps server-rendered
+ * HTML in place until it can be hydrated.
+ */
+export default function LaravelReactI18nProvider({ children, files, locale, fallbackLocale }: I18nProviderProps): import("react").JSX.Element;

package/dist/types/shared/create-i18n.d.ts

@@ -0,0 +1,26 @@
+import type { i18n } from 'i18next';
+import type { LocaleFileSources } from '../interfaces/options';
+export interface LaravelI18nOptions {
+    files: LocaleFileSources;
+    locale?: string;
+    fallbackLocale?: string;
+}
+/**
+ * Locale of the `<html lang="">` attribute (set by Laravel's `app.blade.php`), or `en`.
+ */
+export declare function documentLocale(): string;
+/**
+ * Set the `<html lang="">` attribute to the instance's current language, and keep it
+ * in sync whenever the language changes afterwards.
+ */
+export declare function syncDocumentLang(instance: i18n): () => void;
+/**
+ * Create an i18next instance translating Laravel language files: the default
+ * namespace from `lang/{locale}.json`, and one namespace per `lang/{locale}/{namespace}.json`
+ * file (generated by the Vite plugin, or hand-written).
+ *
+ * With eager files, every known namespace of the locale and fallback locale is
+ * preloaded synchronously, so a first render never has to wait for translations.
+ * With lazy files, namespaces are loaded on demand as components request them.
+ */
+export declare function createI18n({ files, locale, fallbackLocale }: LaravelI18nOptions): i18n;

package/dist/types/svelte/index.d.ts

@@ -0,0 +1,48 @@
+import { type Readable } from 'svelte/store';
+import type { i18n, TFunction } from 'i18next';
+import type { LaravelI18nOptions } from '../shared/create-i18n';
+export interface Translation<N extends string = string> {
+    /** The current translation function, reactive to language and namespace loading. */
+    t: Readable<TFunction<N>>;
+    /** Whether the namespace is loaded (always `true` with eager files). */
+    ready: Readable<boolean>;
+    /** The current language, reactive to `changeLanguage()`. */
+    language: Readable<string>;
+    /** The underlying i18next instance. Not itself reactive; prefer `t`, `ready` and `language`. */
+    i18next: i18n;
+}
+/**
+ * Create an i18next instance translating Laravel language files, and make it
+ * available to `useTranslation()` in child components.
+ *
+ * Every call creates its own instance, so concurrent SSR requests do not share
+ * a language. Must be called during component initialization (top level of `<script>`).
+ *
+ * ```svelte
+ * <script>
+ *   import { setLaravelI18nContext } from '@genrwork/laravel-i18next/svelte';
+ *
+ *   setLaravelI18nContext({
+ *     locale: data.locale,
+ *     fallbackLocale: 'en',
+ *     files: import.meta.glob('/lang/**\/*.json'),
+ *   });
+ * </script>
+ * ```
+ */
+export declare function setLaravelI18nContext(options: LaravelI18nOptions): i18n;
+/**
+ * A reactive `t()` function and `ready` flag for the given namespace, bound to
+ * the i18next instance set with `setLaravelI18nContext()`.
+ *
+ * ```svelte
+ * <script>
+ *   import { useTranslation } from '@genrwork/laravel-i18next/svelte';
+ *
+ *   const { t } = useTranslation('auth');
+ * </script>
+ *
+ * <p>{$t('failed')}</p>
+ * ```
+ */
+export declare function useTranslation<N extends string = string>(namespace?: N, i18nextInstance?: i18n): Translation<N>;

package/dist/types/utils/pluralization.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Select a proper translation string based on the given number,
+ * using the same rules as Laravel's `trans_choice()`.
+ *
+ * @param message
+ * @param number
+ * @param locale
+ */
+export default function pluralization(message: string, number: number, locale: string): string;

package/dist/types/utils/recognizer.d.ts

@@ -0,0 +1,29 @@
+import type { LocaleFileSources } from '../interfaces/options';
+/**
+ * The i18next namespace of a flat `lang/{locale}.json` file (i18next's own default).
+ */
+export declare const DEFAULT_NAMESPACE = "translation";
+/**
+ * A candidate file for a `(locale, namespace)` pair: `source` is the index of
+ * the `LocaleFileSources` entry it came from (lower = higher priority).
+ */
+export interface Candidate {
+    source: number;
+    file: string;
+}
+/**
+ * Recognize the locales and namespaces available from one or more
+ * `LocaleFileSources`, highest priority first.
+ *
+ * @param files
+ */
+export default function recognizer(files: LocaleFileSources): {
+    isLocale: (locale: string) => boolean;
+    getLocales: () => string[];
+    getNamespaces: (locale: string) => string[];
+    getAllNamespaces: () => string[];
+    /** The single highest-priority file, or `undefined` when none exists. */
+    getFile: (locale: string, namespace: string) => string | undefined;
+    /** Every candidate file for the pair, highest priority first. */
+    getCandidates: (locale: string, namespace: string) => Candidate[];
+};

package/dist/types/utils/replacer.d.ts

@@ -0,0 +1,9 @@
+import type ReplacementsInterface from '../interfaces/replacements';
+/**
+ * Make the place-holder replacements on a line, the Laravel way:
+ * `:name` as is, `:NAME` upper-cased and `:Name` capitalized.
+ *
+ * @param message
+ * @param replacements
+ */
+export default function replacer(message: string, replacements?: ReplacementsInterface): string;

package/dist/types/utils/resolver.d.ts

@@ -0,0 +1,23 @@
+import type LocaleFileInterface from '../interfaces/locale-file';
+import type { LocaleFileSources } from '../interfaces/options';
+/**
+ * One resolved candidate: a module directly (eager `import.meta.glob`, or a
+ * plain object) or a promise of one (lazy `import.meta.glob`, or a loader
+ * function already called).
+ */
+export type ResolvedFile = LocaleFileInterface | Promise<LocaleFileInterface>;
+/**
+ * Resolve every candidate language file of a locale's namespace, highest
+ * priority first (see `recognizer().getCandidates()`). Each candidate keeps
+ * its own shape -- eager candidates stay synchronous, lazy ones stay a
+ * promise -- so a caller merging them can still take an all-synchronous path
+ * when every candidate happens to be eager.
+ *
+ * An empty array means the locale has no file at all for that namespace, in
+ * any source.
+ *
+ * @param files
+ * @param locale
+ * @param namespace
+ */
+export default function resolver(files: LocaleFileSources, locale: string, namespace: string): ResolvedFile[];

package/dist/types/utils/sources.d.ts

@@ -0,0 +1,14 @@
+import type { LocaleFiles, LocaleFileSources } from '../interfaces/options';
+/**
+ * Normalize a `LocaleFileSources` (a single `LocaleFiles` map, or an ordered
+ * array of them, highest priority first) into an array, always -- a bare
+ * map behaves like a single-entry array. Non-object entries (e.g. `null`,
+ * defensively) are dropped rather than throwing, so a hand-built array with a
+ * gap does not crash the whole app.
+ *
+ * `Array.isArray` is the discriminator: `LocaleFiles` is itself a plain
+ * `Record<string, unknown>`, which is why every consumer of `files` must call
+ * this before treating it as a map of maps -- `Object.keys()` on a raw array
+ * would otherwise yield `'0'`, `'1'`, ... instead of file paths.
+ */
+export declare function toSources(files: LocaleFileSources): LocaleFiles[];

package/dist/types/vite.d.ts

@@ -0,0 +1,25 @@
+import type { PluginOption } from 'vite';
+export interface ConfigInterface {
+    /**
+     * Ordered, highest priority first. Each entry directory may contain
+     * hand-written `.json` files, `.php` files (each converted to a sibling
+     * `.json`), or both -- but not both for the same namespace, since a
+     * hand-written file is never overwritten (see `src/plugin/parser.ts`).
+     * One `*` segment is allowed per entry, e.g. `'Modules/*\/lang'`, expanded
+     * against every matching directory that exists when the dev server starts
+     * or a build runs. Defaults to `['lang']`.
+     */
+    sources?: string[];
+}
+/**
+ * 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`).
+ */
+export declare const FILES_MODULE_ID = "virtual:laravel-i18next/files";
+/**
+ * Makes Laravel PHP translations available to i18next by generating a sibling
+ * `.json` file next to each `.php` file, across one or more ordered sources.
+ */
+export default function i18n(config?: ConfigInterface): PluginOption;

package/dist/types/vue/index.d.ts

@@ -0,0 +1,21 @@
+import type { Plugin } from 'vue';
+import { useTranslation } from 'i18next-vue';
+import type { LaravelI18nOptions } from '../shared/create-i18n';
+export { useTranslation };
+/**
+ * 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');
+ * ```
+ */
+export declare function laravelVueI18n(options: LaravelI18nOptions): Plugin;