wuchale 0.19.4 → 0.20.0

package/dist/adapter-utils/mixed-visitor.js

@@ -91,7 +91,7 @@ export class MixedVisitor {
         const childrenNestedRanges = [];
         let hasTextDescendants = false;
         const msgs = [];
-        const comments = [];
+        const placeholders = [];
         for (const child of props.children) {
             if (this.isComment(child)) {
                 continue;
@@ -119,9 +119,8 @@ export class MixedVisitor {
                 if (!hasCompoundText) {
                     continue;
                 }
-                const placeholder = `{${iArg}}`;
-                msgStr += placeholder;
-                comments.push(`placeholder ${placeholder}: ${this.mstr.original.slice(chRange.start + 1, chRange.end - 1)}`);
+                msgStr += `{${iArg}}`;
+                placeholders.push([iArg, this.mstr.original.slice(chRange.start + 1, chRange.end - 1)]);
                 let moveStart = chRange.start;
                 if (iArg > 0) {
                     this.mstr.update(chRange.start, chRange.start + 1, ', ');
@@ -172,7 +171,7 @@ export class MixedVisitor {
         }
         const msgInfo = new Message(msgStr, this.fullHeuristicDetails({ scope: props.scope }), props.commentDirectives.context);
         msgInfo.type = heurMsgType;
-        msgInfo.comments = comments;
+        msgInfo.placeholders = placeholders;
         if (hasTextChild || hasTextDescendants) {
             msgs.push(msgInfo);
         }

package/dist/adapter-vanilla/index.d.ts

@@ -5,6 +5,7 @@ export { parseScript, scriptParseOptions, scriptParseOptionsWithComments } from
 export declare const pluralPattern: CodePattern;
 type LoadersAvailable = 'server' | 'vite';
 export type VanillaArgs = AdapterArgs<LoadersAvailable>;
+export declare const defaultArgs: VanillaArgs;
 export declare function getDefaultLoaderPath(loader: LoaderChoice<LoadersAvailable>, bundle: boolean): string | {
     client: string;
     server: string;

package/dist/adapter-vanilla/index.js

@@ -9,7 +9,7 @@ export const pluralPattern = {
     name: 'plural',
     args: ['other', 'message', 'pluralFunc'],
 };
-const defaultArgs = {
+export const defaultArgs = {
     files: { include: 'src/**/*.{js,ts}', ignore: '**/*.d.ts' },
     localesDir: './src/locales',
     patterns: [pluralPattern],

package/dist/adapter-vanilla/transformer.js

@@ -529,13 +529,12 @@ export class Transformer {
     visitTemplateLiteralQuasis = (node, msgTyp) => {
         const msgs = [];
         let msgStr = node.quasis[0].value?.cooked ?? '';
-        const comments = [];
+        const placeholders = [];
         for (const [i, expr] of node.expressions.entries()) {
             msgs.push(...this.visit(expr));
             const quasi = node.quasis[i + 1];
-            const placeholder = `{${i}}`;
-            msgStr += `${placeholder}${quasi.value.cooked}`;
-            comments.push(`placeholder ${placeholder}: ${this.content.slice(expr.start, expr.end)}`);
+            msgStr += `{${i}}${quasi.value.cooked}`;
+            placeholders.push([i, this.content.slice(expr.start, expr.end)]);
             const { start, end } = quasi;
             this.mstr.remove(start - 1, end);
             if (i + 1 === node.expressions.length) {
@@ -545,7 +544,7 @@ export class Transformer {
         }
         const msgInfo = new Message(msgStr, this.fullHeuristicDetails({ scope: 'script' }), this.commentDirectives.context);
         msgInfo.type = msgTyp;
-        msgInfo.comments = comments;
+        msgInfo.placeholders = placeholders;
         const index = this.index.get(msgInfo.toKey());
         msgs.push(msgInfo);
         return [index, msgs];

package/dist/adapters.d.ts

@@ -21,7 +21,7 @@ export declare class Message {
     msgStr: string[];
     plural: boolean;
     context?: string;
-    comments: string[];
+    placeholders: [number, string][];
     details: HeuristicDetails;
     type: MessageType;
     constructor(msgStr: string | (string | null | undefined)[], heuristicDetails?: HeuristicDetails, context?: string);
@@ -100,6 +100,10 @@ export type LoaderPath = {
     client: string;
     server: string;
 };
+export type URLConf = {
+    patterns?: string[];
+    localize?: boolean | URLLocalizer;
+};
 export type AdapterPassThruOpts<RTCtxT extends {} = {}> = {
     sourceLocale?: string;
     files: GlobConf;
@@ -108,10 +112,7 @@ export type AdapterPassThruOpts<RTCtxT extends {} = {}> = {
     outDir?: string;
     granularLoad: boolean;
     bundleLoad: boolean;
-    url?: {
-        patterns?: string[];
-        localize?: boolean | URLLocalizer;
-    };
+    url?: URLConf;
     generateLoadID: (filename: string) => string;
     runtime: Partial<RuntimeConf<RTCtxT>>;
 };

package/dist/adapters.js

@@ -3,7 +3,7 @@ export class Message {
     msgStr; // array for plurals
     plural = false;
     context;
-    comments = [];
+    placeholders = [];
     details;
     type = 'message';
     constructor(msgStr, heuristicDetails = someHeuDet, context) {

package/dist/ai/index.d.ts

@@ -1,9 +1,8 @@
-import PO from 'pofile';
+import { type Item } from '../handler/pofile.js';
 import { type Logger } from '../log.js';
-export type ItemType = InstanceType<typeof PO.Item>;
 type Batch = {
     id: number;
-    messages: ItemType[];
+    messages: Item[];
 };
 export type AI = {
     name: string;
@@ -25,6 +24,6 @@ export default class AIQueue {
     constructor(sourceLang: string, targetLang: string, ai: AI, onComplete: () => Promise<void>, log: Logger);
     translate: (batch: Batch, attempt?: number) => Promise<void>;
     run: () => Promise<void>;
-    add: (messages: ItemType[]) => void;
+    add: (messages: Item[]) => void;
 }
 export {};

package/dist/ai/index.js

@@ -1,6 +1,7 @@
 // $$ cd .. && npm run test
 // $$ node %f
 import PO from 'pofile';
+import { itemToPOItem, poitemToItem } from '../handler/pofile.js';
 import { color } from '../log.js';
 const MAX_RETRIES = 30;
 // implements a queue for a sequential translation useful for vite's transform during dev
@@ -42,9 +43,9 @@ export default class AIQueue {
         let translated;
         try {
             const po = new PO();
-            po.items = batch.messages;
+            po.items = batch.messages.map(itemToPOItem);
             const translatedstr = await this.ai.translate(po.toString(), this.instruction);
-            translated = PO.parse(translatedstr).items;
+            translated = PO.parse(translatedstr).items.map(poitemToItem);
         }
         catch (err) {
             this.log.error(`${logStart}: ${color.red(`error: ${err}`)}`);
@@ -53,7 +54,7 @@ export default class AIQueue {
         const unTranslated = batch.messages.slice(translated.length);
         for (const [i, item] of translated.entries()) {
             const destItem = batch.messages[i];
-            if (item.msgid !== destItem?.msgid) {
+            if (item.msgid.join('\n') !== destItem?.msgid?.join('\n')) {
                 unTranslated.push(destItem);
                 continue;
             }

package/dist/cli/extract.d.ts

@@ -1,2 +1,2 @@
 import type { Config } from '../config.js';
-export declare function extract(config: Config, clean: boolean, watch: boolean, sync: boolean): Promise<void>;
+export declare function extract(config: Config, root: string, clean: boolean, watch: boolean, sync: boolean): Promise<void>;

package/dist/cli/extract.js

@@ -1,28 +1,77 @@
 import { readFile } from 'node:fs/promises';
 import { watch as watchFS } from 'chokidar';
-import { AdapterHandler } from '../handler.js';
+import { glob } from 'tinyglobby';
+import { globConfToArgs } from '../handler/files.js';
+import { AdapterHandler } from '../handler/index.js';
+import { itemIsObsolete } from '../handler/pofile.js';
+import { SharedStates } from '../handler/state.js';
 import { color, Logger } from '../log.js';
-function extractor(handler, logger) {
-    const adapterName = color.magenta(handler.key);
-    return async (filename) => {
-        logger.info(`${adapterName}: Extract from ${color.cyan(filename)}`);
-        const contents = await readFile(filename);
-        await handler.transform(contents.toString(), filename);
-    };
+async function directScanFS(handler, extract, filePaths, clean, sync, logger) {
+    const dumps = new Map();
+    for (const loc of handler.allLocales) {
+        const catalog = handler.sharedState.poFilesByLoc.get(loc).catalog;
+        const items = Array.from(catalog.values());
+        dumps.set(loc, JSON.stringify(items));
+        if (clean) {
+            for (const item of items) {
+                item.references = item.references.filter(ref => {
+                    if (handler.fileMatches(ref.file)) {
+                        return false;
+                    }
+                    if (handler.sharedState.ownerKey !== handler.key) {
+                        return true;
+                    }
+                    return handler.sharedState.otherFileMatches.some(match => match(ref.file));
+                });
+            }
+        }
+        await handler.initUrlPatterns(loc, catalog);
+    }
+    if (sync) {
+        for (const fPath of filePaths) {
+            await extract(fPath);
+        }
+    }
+    else {
+        await Promise.all(filePaths.map(extract));
+    }
+    if (clean) {
+        logger.info('Cleaning...');
+    }
+    for (const loc of handler.allLocales) {
+        const catalog = handler.sharedState.poFilesByLoc.get(loc).catalog;
+        if (clean) {
+            for (const [key, item] of catalog.entries()) {
+                if (itemIsObsolete(item)) {
+                    catalog.delete(key);
+                }
+            }
+        }
+        if (JSON.stringify(Array.from(catalog.values())) !== dumps.get(loc)) {
+            await handler.savePO(loc);
+        }
+    }
 }
-export async function extract(config, clean, watch, sync) {
+export async function extract(config, root, clean, watch, sync) {
     const logger = new Logger(config.logLevel);
     !watch && logger.info('Extracting...');
     const handlers = [];
-    const sharedState = new Map();
+    const sharedState = new SharedStates();
     for (const [key, adapter] of Object.entries(config.adapters)) {
-        const handler = new AdapterHandler(adapter, key, config, 'cli', process.cwd(), logger);
+        const handler = new AdapterHandler(adapter, key, config, 'cli', root, logger);
         await handler.init(sharedState);
-        handlers.push(handler);
+        const adapterName = color.magenta(handler.key);
+        const extract = async (filename) => {
+            logger.info(`${adapterName}: Extract from ${color.cyan(filename)}`);
+            const contents = await readFile(filename);
+            await handler.transform(contents.toString(), filename);
+        };
+        const filePaths = await glob(...globConfToArgs(adapter.files, adapter.localesDir, adapter.outDir));
+        handlers.push([handler, extract, filePaths]);
     }
-    // other loop to make sure that all otherFileMatchers are collected
-    for (const handler of handlers) {
-        await handler.directScanFS(clean, sync);
+    // separate loop to make sure that all otherFileMatchers are collected
+    for (const [handler, extract, files] of handlers) {
+        await directScanFS(handler, extract, files, clean, sync, logger);
     }
     if (!watch) {
         logger.info('Extraction finished.');
@@ -30,13 +79,12 @@ export async function extract(config, clean, watch, sync) {
     }
     // watch
     logger.info('Watching for changes');
-    const handlersWithExtr = handlers.map(h => [h.fileMatches, extractor(h, logger)]);
     watchFS('.', { ignoreInitial: true }).on('all', async (event, filename) => {
         if (!['add', 'change'].includes(event)) {
             return;
         }
-        for (const [fileMatches, extract] of handlersWithExtr) {
-            if (fileMatches(filename)) {
+        for (const [handler, extract] of handlers) {
+            if (handler.fileMatches(filename)) {
                 await extract(filename);
             }
         }

package/dist/cli/index.js

@@ -53,20 +53,21 @@ Options:
     ${color.cyan('--log-level')}, ${color.cyan('-l')}  {${Object.keys(logLevels).map(color.cyan)}} (only when no commands) set log level
     ${color.cyan('--help')}, ${color.cyan('-h')}       Show this help
 `;
-async function getConfigNLocales() {
+async function configRootLocales() {
     const config = await getConfig(values.config);
     config.logLevel = values['log-level'];
-    return [config, config.locales];
+    return [config, values.config ?? process.cwd(), config.locales];
 }
 if (values.help) {
     console.log('wuchale cli');
     console.log(help.trimEnd());
 }
 else if (cmd == null) {
-    await extract((await getConfigNLocales())[0], values.clean, values.watch, values.sync);
+    const [config, root] = await configRootLocales();
+    await extract(config, root, values.clean, values.watch, values.sync);
 }
 else if (cmd === 'status') {
-    await status(...(await getConfigNLocales()));
+    await status(...(await configRootLocales()));
 }
 else {
     console.warn(`${color.yellow('Unknown command')}: ${cmd}`);

package/dist/cli/status.d.ts

@@ -1,2 +1,2 @@
 import { type Config } from '../config.js';
-export declare function status(config: Config, locales: string[]): Promise<void>;
+export declare function status(config: Config, root: string, locales: string[]): Promise<void>;

package/dist/cli/status.js

@@ -1,31 +1,36 @@
+import { relative } from 'node:path';
 import { getLanguageName } from '../config.js';
-import { AdapterHandler, loadPOFile } from '../handler.js';
+import { AdapterHandler } from '../handler/index.js';
+import { POFile } from '../handler/pofile.js';
+import { SharedStates } from '../handler/state.js';
 import { color, Logger } from '../log.js';
-async function statPO(filename) {
-    const po = await loadPOFile(filename);
-    const stats = { total: 0, untranslated: 0, obsolete: 0 };
-    for (const item of po.items) {
-        stats.total++;
+async function statPO(poFile, urlPart) {
+    const po = await poFile.loadRaw(urlPart, false);
+    const stats = { Total: 0, Untranslated: 0, Obsolete: 0 };
+    for (const item of po?.items ?? []) {
+        stats.Total++;
         if (!item.msgstr[0]) {
-            stats.untranslated++;
+            stats.Untranslated++;
         }
         if (item.obsolete) {
-            stats.obsolete++;
+            stats.Obsolete++;
         }
     }
     return stats;
 }
-export async function status(config, locales) {
+export async function status(config, root, locales) {
     // console.log because if the user invokes this command, they want full info regardless of config
     console.log(`Locales: ${locales.map(l => color.cyan(`${l} (${getLanguageName(l)})`)).join(', ')}`);
+    const sharedStates = new SharedStates();
     for (const [key, adapter] of Object.entries(config.adapters)) {
-        const handler = new AdapterHandler(adapter, key, config, 'cli', process.cwd(), new Logger(config.logLevel));
-        const loaderPath = await handler.getLoaderPath();
+        const handler = new AdapterHandler(adapter, key, config, 'cli', root, new Logger(config.logLevel));
+        handler.initSharedState(sharedStates);
+        const loaderPath = await handler.files.getLoaderPath();
         console.log(`${color.magenta(key)}:`);
         if (loaderPath) {
             console.log(`  Loader files:`);
             for (const [side, path] of Object.entries(loaderPath)) {
-                console.log(`    ${color.cyan(side)}: ${color.cyan(path)}`);
+                console.log(`    ${color.cyan(side)}: ${color.cyan(relative(root, path))}`);
             }
         }
         else {
@@ -34,24 +39,17 @@ export async function status(config, locales) {
         }
         const statsData = {};
         for (const locale of locales) {
-            let stats;
-            try {
-                stats = await statPO(handler.catalogFileName(locale));
-            }
-            catch (err) {
-                if (err.code !== 'ENOENT') {
-                    throw err;
+            const locName = getLanguageName(locale);
+            for (const [name, url] of [
+                [locName, false],
+                [`${locName} URL`, true],
+            ]) {
+                const stats = await statPO(handler.sharedState.poFilesByLoc.get(locale), url);
+                if (stats.Total === 0) {
+                    continue;
                 }
-                console.warn(color.yellow('  No catalog found.'));
-                continue;
+                statsData[name] = stats;
             }
-            const { total, obsolete, untranslated } = stats;
-            const locName = getLanguageName(locale);
-            statsData[locName] = {
-                Total: total,
-                Untranslated: untranslated,
-                Obsolete: obsolete,
-            };
         }
         console.table(statsData);
     }

package/dist/config.d.ts

@@ -3,6 +3,7 @@ import type { AI } from './ai/index.js';
 import type { LogLevel } from './log.js';
 export type ConfigPartial = {
     locales: string[];
+    fallback: Record<string, string>;
     ai: AI | null;
     logLevel: LogLevel;
 };

package/dist/config.js

@@ -2,6 +2,7 @@ import { resolve } from 'node:path';
 import { defaultGemini } from './ai/gemini.js';
 export const defaultConfig = {
     locales: ['en'],
+    fallback: {},
     adapters: {},
     hmr: true,
     ai: defaultGemini,

package/dist/handler/files.d.ts

@@ -0,0 +1,31 @@
+import type { Adapter, GlobConf, LoaderPath } from '../adapters.js';
+import type { CompiledElement } from '../compile.js';
+import { type URLManifest } from '../url.js';
+export declare const objKeyLocale: (locale: string) => string;
+export declare function normalizeSep(path: string): string;
+export declare function globConfToArgs(conf: GlobConf, localesDir: string, outDir?: string): [string[], {
+    ignore: string[];
+}];
+export declare class Files {
+    #private;
+    key: string;
+    ownerKey: string;
+    loaderPath: LoaderPath;
+    proxyPath: string;
+    proxySyncPath: string;
+    generatedDir: string;
+    constructor(adapter: Adapter, key: string, root: string);
+    getLoaderPaths(): LoaderPath[];
+    getLoaderPath(): Promise<LoaderPath>;
+    getCompiledFilePath(loc: string, id: string | null): string;
+    getImportPath(filename: string, importer?: string): string;
+    genProxyContent(catalogs: string[], loadIDs: string[], syncImports?: string[]): string;
+    genProxy(locales: string[], loadIDs: string[], loadIDsImport: string[]): string;
+    genProxySync(locales: string[], loadIDs: string[], loadIDsImport: string[]): string;
+    writeProxies: (locales: string[], loadIDs: string[], loadIDsImport: string[]) => Promise<void>;
+    init: (locales: string[], ownerKey: string, sourceLocale: string) => Promise<void>;
+    writeUrlFiles: (manifest: URLManifest, fallbackLocale: string) => Promise<void>;
+    writeCatalogModule: (compiledData: CompiledElement[], pluralRule: string | null, locale: string, hmrVersion: number | null, loadID: string | null) => Promise<void>;
+    writeTransformed: (filename: string, content: string) => Promise<void>;
+    getImportLoaderPath(forServer: boolean, relativeTo: string): string;
+}