@genrwork/laravel-i18next 0.1.0 → 0.1.1

package/dist/vite.cjs

@@ -5,6 +5,7 @@ Object.defineProperty(exports, '__esModule', { value: true });
 var fs = require('fs');
 var path = require('path');
 var vite = require('vite');
+var demand = require('./shared/demand-sbjTXVnl.cjs');
 var phpArrayReader = require('php-array-reader');
 
 /**
@@ -46,10 +47,379 @@ var locale = {
     }
 };
 
+/**
+ * Finds the i18next namespaces a module translates with, by reading its code.
+ * Deliberately a text scan and not a parse: it runs on every module of the
+ * app, on the code of any framework (JSX, Vue and Svelte output alike), and a
+ * namespace it over-reports is harmless -- `preloadI18n()` ignores names that
+ * have no language file.
+ *
+ * Recognized, with string literals only:
+ *
+ * - `useTranslation('auth')`, `useTranslation(['auth', 'teams'])`
+ *   (react-i18next, i18next-vue, and this package's Svelte `useTranslation`);
+ * - `withTranslation('auth')`;
+ * - `ns="auth"` / `ns={'auth'}` (`<Trans>`, `<Translation>`);
+ * - `{ ns: 'auth' }` (`t()` options, `getFixedT`).
+ *
+ * Comments are ignored, so documentation that quotes a call (this package's
+ * own, or commented-out code) declares nothing. A namespace requested through
+ * a variable is invisible to it: declare it with `declareNamespaces()`.
+ */ const CALL = /\b(?:useTranslation|withTranslation)\s*\(\s*(\[[^\]]*\]|"[^"]*"|'[^']*'|`[^`$]*`)/g;
+const JSX_PROP = /\bns\s*=\s*(?:"([^"]+)"|'([^']+)'|\{\s*(?:"([^"]+)"|'([^']+)')\s*\})/g;
+const OPTION = /\bns\s*:\s*(?:"([^"]+)"|'([^']+)')/g;
+/**
+ * A string literal, or a comment: strings are kept, comments dropped. The
+ * `//` inside a string (a URL) must not start a comment, which is why both
+ * are matched by one pattern, strings first.
+ */ const STRING_OR_COMMENT = /("(?:\\.|[^"\\\n])*"|'(?:\\.|[^'\\\n])*'|`(?:\\.|[^`\\])*`)|\/\/[^\n]*|\/\*[\s\S]*?\*\//g;
+const QUOTED = /["'`]([^"'`]+)["'`]/g;
+function detectNamespaces(source) {
+    const found = new Set();
+    if (!/useTranslation|withTranslation|\bns\b/.test(source)) return [];
+    const code = source.replace(STRING_OR_COMMENT, (_match, string)=>string !== null && string !== void 0 ? string : ' ');
+    for (const [, argument] of code.matchAll(CALL)){
+        for (const [, name] of argument.matchAll(QUOTED))found.add(name);
+    }
+    for (const pattern of [
+        JSX_PROP,
+        OPTION
+    ]){
+        for (const match of code.matchAll(pattern)){
+            const name = match.slice(1).find(Boolean);
+            if (name) found.add(name);
+        }
+    }
+    return Array.from(found).sort();
+}
+
+/* eslint-disable */ /**
+ * 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}
+ */ function getPluralIndex(locale, number) {
+    locale = locale.replace('-', '_');
+    if (locale === 'pt_BR') {
+        // temporary set a locale for brazilian
+        locale = 'xbr';
+    }
+    if (locale.length > 3) {
+        locale = locale.substring(0, locale.lastIndexOf('_'));
+    }
+    switch(locale){
+        case 'az':
+        case 'bo':
+        case 'dz':
+        case 'id':
+        case 'ja':
+        case 'jv':
+        case 'ka':
+        case 'km':
+        case 'kn':
+        case 'ko':
+        case 'ms':
+        case 'th':
+        case 'tr':
+        case 'vi':
+        case 'zh':
+            return 0;
+        case 'af':
+        case 'bn':
+        case 'bg':
+        case 'ca':
+        case 'da':
+        case 'de':
+        case 'el':
+        case 'en':
+        case 'eo':
+        case 'es':
+        case 'et':
+        case 'eu':
+        case 'fa':
+        case 'fi':
+        case 'fo':
+        case 'fur':
+        case 'fy':
+        case 'gl':
+        case 'gu':
+        case 'ha':
+        case 'he':
+        case 'hu':
+        case 'is':
+        case 'it':
+        case 'ku':
+        case 'lb':
+        case 'ml':
+        case 'mn':
+        case 'mr':
+        case 'nah':
+        case 'nb':
+        case 'ne':
+        case 'nl':
+        case 'nn':
+        case 'no':
+        case 'om':
+        case 'or':
+        case 'pa':
+        case 'pap':
+        case 'ps':
+        case 'pt':
+        case 'so':
+        case 'sq':
+        case 'sv':
+        case 'sw':
+        case 'ta':
+        case 'te':
+        case 'tk':
+        case 'ur':
+        case 'zu':
+            return number === 1 ? 0 : 1;
+        case 'am':
+        case 'bh':
+        case 'fil':
+        case 'fr':
+        case 'gun':
+        case 'hi':
+        case 'ln':
+        case 'mg':
+        case 'nso':
+        case 'xbr':
+        case 'ti':
+        case 'wa':
+            return number === 0 || number === 1 ? 0 : 1;
+        case 'be':
+        case 'bs':
+        case 'hr':
+        case 'ru':
+        case 'sr':
+        case 'uk':
+            return number % 10 === 1 && number % 100 !== 11 ? 0 : number % 10 >= 2 && number % 10 <= 4 && (number % 100 < 10 || number % 100 >= 20) ? 1 : 2;
+        case 'cs':
+        case 'sk':
+            return number === 1 ? 0 : number >= 2 && number <= 4 ? 1 : 2;
+        case 'ga':
+            return number === 1 ? 0 : number === 2 ? 1 : 2;
+        case 'lt':
+            return number % 10 === 1 && number % 100 !== 11 ? 0 : number % 10 >= 2 && (number % 100 < 10 || number % 100 >= 20) ? 1 : 2;
+        case 'sl':
+            return number % 100 === 1 ? 0 : number % 100 === 2 ? 1 : number % 100 === 3 || number % 100 === 4 ? 2 : 3;
+        case 'mk':
+            return number % 10 === 1 ? 0 : 1;
+        case 'mt':
+            return number === 1 ? 0 : number === 0 || number % 100 > 1 && number % 100 < 11 ? 1 : number % 100 > 10 && number % 100 < 20 ? 2 : 3;
+        case 'lv':
+            return number === 0 ? 0 : number % 10 === 1 && number % 100 !== 11 ? 1 : 2;
+        case 'pl':
+            return number === 1 ? 0 : number % 10 >= 2 && number % 10 <= 4 && (number % 100 < 12 || number % 100 > 14) ? 1 : 2;
+        case 'cy':
+            return number === 1 ? 0 : number === 2 ? 1 : number === 8 || number === 11 ? 2 : 3;
+        case 'ro':
+            return number === 1 ? 0 : number === 0 || number % 100 > 0 && number % 100 < 20 ? 1 : 2;
+        case 'ar':
+            return number === 0 ? 0 : number === 1 ? 1 : number === 2 ? 2 : number >= 3 && number <= 10 ? 3 : number >= 11 && number <= 99 ? 4 : 5;
+        default:
+            return 0;
+    }
+}
+
+/**
+ * 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
+ */ function pluralization(message, number, locale) {
+    let segments = message.split('|');
+    const extracted = extract(segments, number);
+    if (extracted !== null) {
+        return extracted.trim();
+    }
+    segments = stripConditions(segments);
+    const pluralIndex = getPluralIndex(locale, number);
+    return segments.length === 1 || !segments[pluralIndex] ? segments[0] : segments[pluralIndex];
+}
+/**
+ * Extract a translation string using inline conditions.
+ *
+ * @param segments
+ * @param number
+ */ function extract(segments, number) {
+    for (const segment of segments){
+        const result = extractFromString(segment, number);
+        if (result !== null) return result;
+    }
+    return null;
+}
+/**
+ * Get the translation string if the condition matches.
+ *
+ * @param part
+ * @param number
+ */ function extractFromString(part, number) {
+    const matches = part.match(/^[{[]([^,{}[\]]*),?([^{}[\]]*)[}\]]([\s\S]*)/);
+    if (!matches) return null;
+    const [, from, to, value] = matches;
+    if ((from === '*' || number >= parseFloat(from)) && (to === '*' || number <= parseFloat(to))) {
+        return value;
+    }
+    return from && parseFloat(from) === number ? value : null;
+}
+/**
+ * Strip the inline conditions from each segment, just leaving the text.
+ *
+ * @param segments
+ */ function stripConditions(segments) {
+    return segments.map((part)=>part.replace(/^[{[]([^[\]{}]*)[}\]]/, ''));
+}
+
+/**
+ * Converts one Laravel translation message into the i18next way, at build
+ * time, so the browser only ever sees i18next JSON:
+ *
+ * - `:name` becomes `{{name}}`, `:NAME` becomes `{{name, uppercase}}` and
+ *   `:Name` becomes `{{name, capitalize}}` (formats registered by
+ *   `registerCaseFormats()`);
+ * - a `|` separated message (Laravel's `trans_choice()` forms, with or
+ *   without `{0}` / `[1,19]` conditions) becomes i18next's plural keys
+ *   (`key_one`, `key_other`, ...) for the language of the file, plus the raw
+ *   message under the plain key, which is what Laravel's `trans()` returns
+ *   when no count is given.
+ */ /**
+ * A Laravel placeholder: a colon followed by a name, not glued to a word before
+ * it, so `https://`, `10:30` and `Note:this` are text.
+ */ const PLACEHOLDER = /(?<!\w):([A-Za-z_][A-Za-z0-9_]*)/g;
+/**
+ * i18next's plural categories, in its own order (see `getSuffixes()`).
+ */ const CATEGORY_ORDER = [
+    'zero',
+    'one',
+    'two',
+    'few',
+    'many',
+    'other'
+];
+/**
+ * Whole counts a message is checked against: every count that matters for
+ * plural rules, plus a few large ones for the categories that only start there
+ * (`many` of Spanish, French and Italian begins at a million).
+ */ const SAMPLES = [
+    ...Array.from({
+        length: 1001
+    }, (_, count)=>count),
+    1e6,
+    2e6,
+    1e9
+];
+/**
+ * Rewrite Laravel placeholders as i18next interpolations.
+ */ function toInterpolation(message) {
+    return message.replace(PLACEHOLDER, (_match, name)=>{
+        const hasLetters = name !== name.toLowerCase() || name !== name.toUpperCase();
+        if (hasLetters && name === name.toUpperCase()) return `{{${name.toLowerCase()}, uppercase}}`;
+        if (name[0] !== name[0].toLowerCase()) return `{{${name[0].toLowerCase()}${name.slice(1)}, capitalize}}`;
+        return `{{${name}}}`;
+    });
+}
+/**
+ * The plural categories a language distinguishes, in i18next's order.
+ */ function categoriesOf(rules) {
+    return rules.resolvedOptions().pluralCategories.slice().sort((left, right)=>CATEGORY_ORDER.indexOf(left) - CATEGORY_ORDER.indexOf(right));
+}
+function pluralRulesOf(locale) {
+    try {
+        return new Intl.PluralRules(locale.replace(/_/g, '-'));
+    } catch  {
+        return new Intl.PluralRules('en');
+    }
+}
+/**
+ * Split a pluralized Laravel message into one message per i18next plural
+ * category by asking Laravel's own rules (`pluralization()`) what they answer
+ * for whole counts, then checking that every count of a category agrees.
+ * A message Laravel answers differently inside one category -- `[2,19]` next
+ * to `[20,*]` in English -- cannot be written as i18next plural keys and is
+ * refused, rather than silently translated wrongly.
+ *
+ * Count `0` may differ from its category (`{0} none|...`): it is written as
+ * `_zero`, which i18next tries first for a count of 0 in every language.
+ */ function pluralForms(key, message, locale) {
+    var _a;
+    const rules = pluralRulesOf(locale);
+    const categories = categoriesOf(rules);
+    const forms = new Map();
+    SAMPLES.forEach((count)=>{
+        if (count === 0) return;
+        const category = rules.select(count);
+        const text = pluralization(message, count, locale);
+        const known = forms.get(category);
+        if (known && known.text !== text) {
+            throw new Error(`Cannot convert "${key}" (${locale}) to i18next plural forms: Laravel answers "${known.text}" for a count of ` + `${known.count} and "${text}" for ${count}, which i18next treats as the same plural category ("${category}"). ` + 'Split it into separate keys, or write it as i18next JSON.');
+        }
+        if (!known) forms.set(category, {
+            text,
+            count
+        });
+    });
+    const zero = pluralization(message, 0, locale);
+    const zeroCategory = rules.select(0);
+    const result = {};
+    // A category no whole count reaches (`other` in Russian) reads like the largest category.
+    const fallback = (_a = [
+        ...categories
+    ].reverse().map((category)=>{
+        var _a;
+        return (_a = forms.get(category)) === null || _a === void 0 ? void 0 : _a.text;
+    }).find(Boolean)) !== null && _a !== void 0 ? _a : zero;
+    categories.forEach((category)=>{
+        var _a, _b;
+        result[category] = (_b = (_a = forms.get(category)) === null || _a === void 0 ? void 0 : _a.text) !== null && _b !== void 0 ? _b : category === zeroCategory ? zero : fallback;
+    });
+    if (zero !== result[zeroCategory]) result.zero = zero;
+    return result;
+}
+/**
+ * Convert one entry, returning the i18next entries it becomes (one for a
+ * plain message, several for a pluralized one). A list has its messages
+ * converted, anything else that is not a string is returned untouched.
+ */ function convertEntry(key, value, locale) {
+    if (Array.isArray(value)) {
+        return {
+            [key]: value.map((item)=>typeof item === 'string' ? toInterpolation(item) : item)
+        };
+    }
+    if (typeof value !== 'string') return {
+        [key]: value
+    };
+    if (!value.includes('|')) return {
+        [key]: toInterpolation(value)
+    };
+    const entries = {
+        [key]: toInterpolation(value)
+    };
+    const forms = pluralForms(key, value, locale);
+    CATEGORY_ORDER.filter((category)=>category in forms).forEach((category)=>{
+        entries[`${key}_${category}`] = toInterpolation(forms[category]);
+    });
+    return entries;
+}
+
 /**
  * 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.
+ * The PHP file keeps Laravel's conventions (`:name` placeholders, `one|many`
+ * plural forms); the JSON is written the i18next way (`{{name}}`,
+ * `key_one` / `key_other`), see `src/plugin/convert.ts`.
  * 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
@@ -78,7 +448,8 @@ var locale = {
  */ function generateNamespaceFiles(localeDirname) {
     return walkPhpFiles(localeDirname).sort().map((phpPath)=>{
         const content = fs.readFileSync(phpPath, 'utf-8');
-        const translations = convertToDottedKey(phpArrayReader.fromString(content));
+        const locale = path.basename(localeDirname);
+        const translations = convertToI18next(convertToDottedKey(phpArrayReader.fromString(content)), locale);
         const outputPath = phpPath.replace(/\.php$/, '.json');
         fs.writeFileSync(outputPath, JSON.stringify(translations));
         return {
@@ -102,6 +473,14 @@ var locale = {
         ] : [];
     });
 }
+/**
+ * Rewrite every flattened Laravel message the i18next way for a language.
+ *
+ * @param source
+ * @param locale
+ */ function convertToI18next(source, locale) {
+    return Object.entries(source).reduce((target, [key, value])=>Object.assign(target, convertEntry(key, value, locale)), {});
+}
 /**
  * Flatten nested translations into dotted keys, e.g. `sub_level1.sub_level2.text`.
  *
@@ -133,7 +512,7 @@ function countWildcardSegments(normalizedPattern) {
  * 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
+ * with exactly one `*` segment (e.g. `packages/*\/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.
@@ -166,8 +545,8 @@ function countWildcardSegments(normalizedPattern) {
  * 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
+ * the emitted glob needs no separate wildcard handling: `packages/*\/lang`
+ * becomes `/packages/*\/lang/**\/*.json` and `import.meta.glob()` expands the
  * `*` itself, natively, at both dev and build time.
  *
  * @param pattern
@@ -187,6 +566,10 @@ function countWildcardSegments(normalizedPattern) {
     return dirnames.some((dir)=>normalizedFile.startsWith(`${vite.normalizePath(dir)}/`));
 }
 
+/**
+ * The modules the namespace declaration is added to: the app's own scripts and
+ * single-file components, never dependencies.
+ */ const SCRIPT_MODULE = /\.(?:[cm]?[jt]sx?|vue|svelte)$/;
 /**
  * Language files, one namespace per language file: loaded eagerly by server
  * code (SSR), so it renders translated, and lazily by client code. The
@@ -198,13 +581,15 @@ 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;
+    var _a, _b, _c;
     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'
     ];
+    const eagerOnServer = ((_b = config === null || config === void 0 ? void 0 : config.ssr) !== null && _b !== void 0 ? _b : 'eager') === 'eager';
+    const detect = (_c = config === null || config === void 0 ? void 0 : config.detectNamespaces) !== null && _c !== void 0 ? _c : true;
     let root = process.cwd();
     let generated = [];
     let exitHandlersBound = false;
@@ -267,9 +652,26 @@ const RESOLVED_FILES_MODULE_ID = `\0${FILES_MODULE_ID}`;
             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(', ');
+            const entries = sourcePatterns.map((pattern)=>JSON.stringify(toGlob(pattern, root))).map((pattern)=>(options === null || options === void 0 ? void 0 : options.ssr) && eagerOnServer ? `import.meta.glob(${pattern}, { eager: true })` : `import.meta.glob(${pattern})`).join(', ');
             return `export default [${entries}];`;
         },
+        transform (code, id) {
+            const file = id.split('?')[0];
+            if (!detect || id.charCodeAt(0) === 0 || file.includes('/node_modules/') || !SCRIPT_MODULE.test(file)) {
+                return undefined;
+            }
+            const namespaces = detectNamespaces(code);
+            if (namespaces.length === 0) return undefined;
+            // Self-contained (see `src/demand.ts` for why it imports nothing), and
+            // on the first line so no line of the module moves.
+            const registry = `globalThis[Symbol.for(${JSON.stringify(demand.DECLARED_NAMESPACES_KEY)})]`;
+            const adds = namespaces.map((namespace)=>`.add(${JSON.stringify(namespace)})`).join('');
+            const declaration = `(${registry}||(${registry}=new Set))${adds};`;
+            return {
+                code: declaration + code,
+                map: null
+            };
+        },
         config (userConfig) {
             var _a;
             // `config()` runs before `configResolved()`, so `root` is not yet the