wuchale 0.21.1 → 0.22.0

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

@@ -49,13 +49,15 @@ export declare class Transformer<RTCtxT = {}> {
     visitAwaitExpression: (node: Estree.AwaitExpression) => Message[];
     visitAssignmentExpression: (node: Estree.BinaryExpression) => Message[];
     visitAssignmentPattern: (node: Estree.AssignmentPattern) => Message[];
-    visitExpressionStatement: (node: Estree.ExpressionStatement) => Message[];
     visitForOfStatement: (node: Estree.ForOfStatement) => Message[];
     visitForInStatement: (node: Estree.ForInStatement) => Message[];
     visitForStatement: (node: Estree.ForStatement) => Message[];
     getMemberChainName: (node: Estree.MemberExpression) => string;
     getCalleeName: (callee: Estree.Expression | Estree.Super) => string;
+    getActualExpression(expr?: Estree.Expression | Estree.TSAsExpression | Estree.TSTypeAssertion): Estree.Expression | null;
+    withUpdateTLDetails(visit: (atTopLevel: boolean) => Message[]): Message[];
     defaultVisitVariableDeclarator: (node: Estree.VariableDeclarator) => Message[];
+    visitExpressionStatement: (node: Estree.ExpressionStatement) => Message[];
     visitVariableDeclarator: (node: Estree.VariableDeclarator) => Message[];
     visitVariableDeclaration: (node: Estree.VariableDeclaration) => Message[];
     visitExportNamedDeclaration: (node: Estree.ExportNamedDeclaration) => Message[];
@@ -76,12 +78,8 @@ export declare class Transformer<RTCtxT = {}> {
     visitTaggedTemplateExpression: (node: Estree.TaggedTemplateExpression) => Message[];
     visitSwitchStatement: (node: Estree.SwitchStatement) => Message[];
     visitTryStatement: (node: Estree.TryStatement) => Message[];
-    visitTSAsExpression: (node: {
-        expression: Estree.AnyNode;
-    }) => Message[];
-    visitTSTypeAssertion: (node: {
-        expression: Estree.AnyNode;
-    }) => Message[];
+    visitTSAsExpression: (node: Estree.TSAsExpression) => Message[];
+    visitTSTypeAssertion: (node: Estree.TSTypeAssertion) => Message[];
     visitProgram: (node: Estree.Program) => Message[];
     visitWithCommentDirectives: (node: Estree.AnyNode, func: Function) => any;
     visit: (node: Estree.AnyNode) => Message[];

package/dist/adapter-vanilla/transformer.js

@@ -113,16 +113,13 @@ export class Transformer {
             }
             const wrapInit = initReactive ? rtConf.reactive.wrapInit : rtConf.plain.wrapInit;
             const expr = initReactive ? catalogExpr.reactive : catalogExpr.plain;
-            return `\nconst ${this.currentRtVar} = ${wrapInit(expr)}\n`;
+            return `\nconst ${this.currentRtVar} = ${wrapInit(expr)};\n`;
         };
     }
-    fullHeuristicDetails = (detailsBase) => {
-        const details = { ...this.heuristciDetails, ...detailsBase };
-        if (details.declaring == null && details.insideProgram) {
-            details.declaring = 'expression';
-        }
-        return details;
-    };
+    fullHeuristicDetails = (detailsBase) => ({
+        ...this.heuristciDetails,
+        ...detailsBase,
+    });
     getHeuristicMessageType = (msg) => {
         const msgStr = msg.msgStr.join('\n');
         if (!msgStr) {
@@ -334,7 +331,6 @@ export class Transformer {
         ...this.visit(node.left),
         ...this.visit(node.right),
     ];
-    visitExpressionStatement = (node) => this.visit(node.expression);
     visitForOfStatement = (node) => [
         ...this.visit(node.left),
         ...this.visit(node.right),
@@ -390,29 +386,53 @@ export class Transformer {
         }
         return `[${callee.type}]`;
     };
-    defaultVisitVariableDeclarator = (node) => {
+    getActualExpression(expr) {
+        if (!expr) {
+            return null;
+        }
+        if (expr.type === 'TSAsExpression' || expr.type === 'TSTypeAssertion') {
+            return expr.expression;
+        }
+        return expr;
+    }
+    withUpdateTLDetails(visit) {
         const atTopLevelDefn = this.heuristciDetails.insideProgram && !this.heuristciDetails.declaring;
+        const msgs = visit(atTopLevelDefn);
+        if (atTopLevelDefn) {
+            this.heuristciDetails.topLevelCall = undefined; // reset
+            this.heuristciDetails.declaring = undefined;
+        }
+        return msgs;
+    }
+    defaultVisitVariableDeclarator = (node) => this.withUpdateTLDetails(topLevel => {
         if (!node.init) {
             return [];
         }
-        if (atTopLevelDefn) {
-            if (node.init.type === 'ArrowFunctionExpression' || node.init.type === 'FunctionExpression') {
+        const init = this.getActualExpression(node.init);
+        if (topLevel) {
+            if (init.type === 'ArrowFunctionExpression' || init.type === 'FunctionExpression') {
                 this.heuristciDetails.declaring = 'function';
             }
             else {
                 this.heuristciDetails.declaring = 'variable';
-                if (node.init.type === 'CallExpression') {
-                    this.heuristciDetails.topLevelCall = this.getCalleeName(node.init.callee);
-                }
             }
         }
-        const msgs = [...this.visit(node.id), ...this.visit(node.init)];
-        if (atTopLevelDefn) {
-            this.heuristciDetails.topLevelCall = undefined; // reset
-            this.heuristciDetails.declaring = undefined;
+        const msgs = this.visit(node.id);
+        if (topLevel && this.heuristciDetails.declaring === 'variable' && init.type === 'CallExpression') {
+            this.heuristciDetails.topLevelCall = this.getCalleeName(init.callee);
         }
-        return msgs;
-    };
+        return [...msgs, ...this.visit(node.init)];
+    });
+    visitExpressionStatement = (node) => this.withUpdateTLDetails(topLevel => {
+        const expr = this.getActualExpression(node.expression);
+        if (topLevel) {
+            this.heuristciDetails.declaring = 'expression';
+            if (expr.type === 'CallExpression') {
+                this.heuristciDetails.topLevelCall = this.getCalleeName(expr.callee);
+            }
+        }
+        return this.visit(expr);
+    });
     // for e.g. svelte to surrounded with $derived
     visitVariableDeclarator = this.defaultVisitVariableDeclarator;
     visitVariableDeclaration = (node) => node.declarations.flatMap(this.visitVariableDeclarator);

package/dist/adapters.js

@@ -71,7 +71,7 @@ export function createHeuristic(opts) {
         if (msg.details.scope === 'attribute') {
             return 'message';
         }
-        if (msg.details.declaring === 'expression' && !msg.details.funcName) {
+        if (msg.details.declaring === 'expression' && msg.details.funcName == null) {
             return false;
         }
         if (!msg.details.call ||

package/dist/ai/index.js

@@ -87,10 +87,11 @@ export default class AIQueue {
         const unTranslated = batch.messages.slice(translated.length);
         for (const [i, outItem] of translated.entries()) {
             const item = batch.messages[i];
-            const sourceComp = item.id.map(i => compileTranslation(i, ''));
+            const id = item.translations.get(this.sourceLocale);
+            const sourceComp = id.map(i => compileTranslation(i, ''));
             for (const loc of batch.targetLocales) {
                 const translation = outItem[loc];
-                if (translation?.length !== item.id.length) {
+                if (translation?.length !== id.length) {
                     unTranslated.push(item);
                     break;
                 }

package/dist/bundlers/vite.d.ts

@@ -0,0 +1,32 @@
+export declare function toViteError(err: unknown, adapterKey: string, filename: string): never;
+export declare function trimViteQueries(id: string): string;
+type HotUpdateCtx = {
+    file: string;
+    server: {
+        ws: {
+            send: Function;
+        };
+        moduleGraph: {
+            getModulesByFile: Function;
+            invalidateModule: Function;
+        };
+    };
+    read: () => string | Promise<string>;
+    timestamp: number;
+};
+export declare const wuchale: (configPath?: string, hmrDelayThreshold?: number) => {
+    name: string;
+    configResolved(config: {
+        env: {
+            DEV?: boolean;
+        };
+    }): Promise<void>;
+    handleHotUpdate(ctx: HotUpdateCtx): Promise<never[] | undefined>;
+    transform: {
+        order: "pre";
+        handler(code: string, id: string, options?: {
+            ssr?: boolean | undefined;
+        }): Promise<import("wuchale").TransformOutputCode>;
+    };
+};
+export {};

package/dist/bundlers/vite.js

@@ -0,0 +1,70 @@
+import { dirname } from 'node:path';
+import { inspect } from 'node:util';
+import { getConfig } from 'wuchale';
+import { Hub, pluginName } from '../hub.js';
+export function toViteError(err, adapterKey, filename) {
+    const prefix = `${adapterKey}: transform failed for ${filename}`;
+    // Ensure we always throw an Error instance with a non-empty message so build tools (e.g. Vite)
+    // don't end up printing only a generic "error during build:" line.
+    if (err instanceof Error) {
+        const anyErr = err;
+        const frame = typeof anyErr.frame === 'string' ? anyErr.frame : undefined;
+        if (!err.message || !err.message.startsWith(prefix)) {
+            const details = err.message ? `\n${err.message}` : '';
+            const frameText = frame ? `\n\n${frame}` : '';
+            err.message = `${prefix}${details}${frameText}`;
+        }
+        // Preserve useful metadata that some tooling expects.
+        if (anyErr.id == null)
+            anyErr.id = filename;
+        if (anyErr.loc == null && anyErr.start?.line != null && anyErr.start?.column != null) {
+            anyErr.loc = { file: filename, line: anyErr.start.line, column: anyErr.start.column };
+        }
+        throw err;
+    }
+    const rendered = typeof err === 'string' ? err : inspect(err, { depth: 5, breakLength: 120, maxStringLength: 10_000 });
+    throw new Error(`${prefix}\n${rendered}`);
+}
+export function trimViteQueries(id) {
+    let queryIndex = id.indexOf('?v=');
+    if (queryIndex === -1) {
+        queryIndex = id.indexOf('?t=');
+    }
+    if (queryIndex >= 0 && !id.includes('&', queryIndex)) {
+        // trim after this, like ?v=b65b2c3b when it's from node_modules
+        id = id.slice(0, queryIndex);
+    }
+    return id;
+}
+export const wuchale = (configPath, hmrDelayThreshold = 1000) => {
+    const hub = new Hub(() => getConfig(configPath), dirname(configPath ?? '.'), hmrDelayThreshold);
+    return {
+        name: pluginName,
+        async configResolved(config) {
+            await hub.init(config.env.DEV ? 'dev' : 'build');
+        },
+        async handleHotUpdate(ctx) {
+            const changeInfo = await hub.onFileChange(ctx.file, ctx.read);
+            if (!changeInfo) {
+                return;
+            }
+            const invalidatedModules = new Set();
+            for (const fileID of changeInfo.invalidate ?? []) {
+                for (const module of ctx.server.moduleGraph.getModulesByFile(fileID) ?? []) {
+                    ctx.server.moduleGraph.invalidateModule(module, invalidatedModules, ctx.timestamp, false);
+                }
+            }
+            if (!changeInfo.sourceTriggered) {
+                ctx.server.ws.send({ type: 'full-reload' });
+                return [];
+            }
+        },
+        transform: {
+            order: 'pre',
+            async handler(code, id, options) {
+                const [output] = await hub.transform(code, trimViteQueries(id), options?.ssr);
+                return output;
+            },
+        },
+    };
+};

package/dist/cli/check.d.ts

@@ -0,0 +1,3 @@
+import { type Config } from '../config.js';
+export declare const checkHelp: string;
+export declare function check(config: Config, root: string, full: boolean): Promise<void>;

package/dist/cli/check.js

@@ -0,0 +1,35 @@
+import {} from '../config.js';
+import { readOnlyFS } from '../fs.js';
+import { Hub } from '../hub.js';
+import { color } from '../log.js';
+export const checkHelp = `
+Usage:
+    ${color.cyan('wuchale check {options}')}
+
+Options:
+    ${color.cyan('--full')}           check if there are unextracted and newly obsolete messages in source code as well
+    ${color.cyan('--help')}, ${color.cyan('-h')}       Show this help
+`;
+const checkErrMsgs = {
+    notEquivalent: 'Not equivalent',
+    unequalLength: 'Unequal length',
+};
+export async function check(config, root, full) {
+    // console.log because if the user invokes this command, they want full info regardless of config
+    const hub = new Hub(() => config, root, 0, readOnlyFS);
+    await hub.init('cli');
+    const { checked, errors, syncs } = await hub.check(full);
+    for (const err of errors) {
+        console.error(`${color.magenta(err.adapter)}: ${color.red(checkErrMsgs[err.type])}`);
+        console.error(`  ${color.grey('Source:')} ${err.source}`);
+        console.error(`  ${color.grey('Target locale:')} ${err.locale}`);
+        console.error(`  ${color.grey('Translation:')} ${err.translation}`);
+    }
+    for (const key of syncs) {
+        console.error(`${color.red(key)}: Pending changes`);
+    }
+    if (errors.length > 0 || syncs.length > 0) {
+        process.exit(1);
+    }
+    console.log(color.green(`${checked} items checked. No errors found`));
+}

package/dist/cli/index.js

@@ -1,9 +1,11 @@
 #!/usr/bin/env node
+import { dirname } from 'node:path';
 import { parseArgs } from 'node:util';
 import { defaultConfigNames, getConfig } from '../config.js';
+import { Hub } from '../hub.js';
 import { color, logLevels } from '../log.js';
-import { extract } from './extract.js';
-import { status } from './status.js';
+import { check, checkHelp } from './check.js';
+import { status, statusHelp } from './status.js';
 const { positionals, values } = parseArgs({
     options: {
         config: {
@@ -19,6 +21,14 @@ const { positionals, values } = parseArgs({
             short: 'w',
             default: false,
         },
+        json: {
+            type: 'boolean',
+            default: false,
+        },
+        full: {
+            type: 'boolean',
+            default: false,
+        },
         sync: {
             type: 'boolean',
             default: false,
@@ -44,30 +54,51 @@ Commands:
     ${color.grey('[none]')}  Extract/compile messages from the codebase into catalogs
             deleting unused messages if ${color.cyan('--clean')} is specified
     ${color.cyan('status')}  Show current status
+    ${color.cyan('check')}   Check for errors
 
 Options:
     ${color.cyan('--config')}         use another config file instead of ${defaultConfigNames.map(color.cyan).join('|')}
-    ${color.cyan('--clean')}, ${color.cyan('-c')}      (only when no commands) remove unused messages from catalogs
-    ${color.cyan('--watch')}, ${color.cyan('-w')}      (only when no commands) continuously watch for file changes
-    ${color.cyan('--sync')}           (only when no commands) extract sequentially instead of in parallel
+    ${color.cyan('--clean')}, ${color.cyan('-c')}      remove unused messages from catalogs
+    ${color.cyan('--watch')}, ${color.cyan('-w')}      continuously watch for file changes
+    ${color.cyan('--sync')}           extract sequentially instead of in parallel
     ${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
+
+You can specify ${color.cyan('--help')} after a sub-command for more.
 `;
 async function configRootLocales() {
     const config = await getConfig(values.config);
     config.logLevel = values['log-level'];
-    return [config, values.config ?? process.cwd(), config.locales];
+    const root = values.config ? dirname(values.config) : process.cwd();
+    return [config, root, config.locales];
+}
+if (cmd === 'status') {
+    if (values.help) {
+        console.log(statusHelp);
+    }
+    else {
+        const [config, root] = await configRootLocales();
+        await status(config, root, values.json);
+    }
 }
-if (values.help) {
+else if (cmd === 'check') {
+    if (values.help) {
+        console.log(checkHelp);
+    }
+    else {
+        const [config, root] = await configRootLocales();
+        await check(config, root, values.full);
+    }
+}
+else if (values.help) {
     console.log('wuchale cli');
     console.log(help.trimEnd());
 }
 else if (cmd == null) {
     const [config, root] = await configRootLocales();
-    await extract(config, root, values.clean, values.watch, values.sync);
-}
-else if (cmd === 'status') {
-    await status(...(await configRootLocales()));
+    const hub = new Hub(() => config, root);
+    await hub.init('cli');
+    await hub.directVisit(values.clean, values.watch, values.sync);
 }
 else {
     console.warn(`${color.yellow('Unknown command')}: ${cmd}`);

package/dist/cli/status.d.ts

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

package/dist/cli/status.js

@@ -1,59 +1,47 @@
 import { relative } from 'node:path';
 import { getLanguageName } from '../config.js';
-import { AdapterHandler } from '../handler/index.js';
-import { SharedStates } from '../handler/state.js';
-import { color, Logger } from '../log.js';
-import { itemIsObsolete, itemIsUrl } from '../storage.js';
-async function statCatalog(locale, catalog, urls) {
-    const stats = { Total: 0, Untranslated: 0, Obsolete: 0 };
-    for (const item of catalog.values()) {
-        if (itemIsUrl(item) !== urls) {
-            continue;
-        }
-        stats.Total++;
-        if (!item.translations.get(locale)[0]) {
-            stats.Untranslated++;
-        }
-        if (itemIsObsolete(item)) {
-            stats.Obsolete++;
-        }
-    }
-    return stats;
-}
-export async function status(config, root, locales) {
+import { readOnlyFS } from '../fs.js';
+import { Hub } from '../hub.js';
+import { color } from '../log.js';
+export const statusHelp = `
+Usage:
+    ${color.cyan('wuchale status {options}')}
+
+Options:
+    ${color.cyan('--json')}           output info as structured JSON instead of table and text
+    ${color.cyan('--help')}, ${color.cyan('-h')}       Show this help
+`;
+export async function status(config, root, json) {
     // 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', root, new Logger(config.logLevel));
-        handler.initSharedState(sharedStates);
-        const state = handler.sharedState;
-        const loaderPath = await handler.files.getLoaderPath();
-        console.log(`${color.magenta(key)}: ${color.cyan(state.catalog.size)} messages`);
-        if (loaderPath) {
+    const hub = new Hub(() => config, root, 0, readOnlyFS);
+    await hub.init('cli');
+    if (json) {
+        console.log(JSON.stringify(await hub.status(), null, process.stdout.isTTY ? '  ' : undefined));
+        return;
+    }
+    for (const stat of await hub.status()) {
+        console.log(`${color.magenta(stat.key)}:`);
+        if (stat.loaders) {
             console.log(`  Loader files:`);
-            for (const [side, path] of Object.entries(loaderPath)) {
+            for (const [side, path] of Object.entries(stat.loaders)) {
                 console.log(`    ${color.cyan(side)}: ${color.cyan(relative(root, path))}`);
             }
         }
         else {
             console.warn(color.yellow('  No loader file found.'));
-            console.log(`  Run ${color.cyan('npx wuchale init')} to initialize.`);
+            console.log(`  Run ${color.cyan('npx wuchale')} to initialize.`);
         }
+        if (!stat.storage.own) {
+            console.log(`  Storage shared with ${color.magenta(stat.storage.ownerKey)}`);
+            continue;
+        }
+        console.log(`  Messages: ${color.cyan(stat.storage.total)} (${color.cyan(stat.storage.url)} URL)`);
         const statsData = {};
-        for (const locale of locales) {
-            const locName = getLanguageName(locale);
-            for (const [name, url] of [
-                [locName, false],
-                [`${locName} URL`, true],
-            ]) {
-                await state.load(locales);
-                const stats = await statCatalog(locale, state.catalog, url);
-                if (stats.Total === 0) {
-                    continue;
-                }
-                statsData[name] = stats;
-            }
+        for (const det of stat.storage.details) {
+            statsData[getLanguageName(det.locale)] = {
+                Obsolete: det.obsolete,
+                Untranslated: det.untranslated,
+            };
         }
         console.table(statsData);
     }

package/dist/fs.d.ts

@@ -0,0 +1,8 @@
+export type FS = {
+    read(file: string): string | Promise<string>;
+    write(file: string, content: string): void | Promise<void>;
+    mkdir(path: string): void | Promise<void>;
+    exists(path: string): boolean | Promise<boolean>;
+};
+export declare const defaultFS: FS;
+export declare const readOnlyFS: FS;

package/dist/fs.js

@@ -0,0 +1,29 @@
+import { mkdir, readFile, statfs, writeFile } from 'node:fs/promises';
+export const defaultFS = {
+    async read(file) {
+        return await readFile(file, 'utf-8');
+    },
+    async write(file, content) {
+        await writeFile(file, content);
+    },
+    async mkdir(path) {
+        await mkdir(path, { recursive: true });
+    },
+    async exists(path) {
+        try {
+            await statfs(path);
+            return true;
+        }
+        catch (err) {
+            if (err.code !== 'ENOENT') {
+                throw err;
+            }
+            return false;
+        }
+    },
+};
+export const readOnlyFS = {
+    ...defaultFS,
+    write: () => { },
+    mkdir: () => { },
+};

package/dist/handler/files.d.ts

@@ -1,10 +1,18 @@
 import type { Adapter, GlobConf, LoaderPath } from '../adapters.js';
 import type { CompiledElement } from '../compile.js';
+import type { FS } from '../fs.js';
 import { type URLManifest } from '../url.js';
+export declare const dataFileName = "data.js";
 export declare const generatedDir = ".wuchale";
+export type ManifestEntryObj = {
+    text: string | string[];
+    context?: string;
+    isUrl?: boolean;
+};
+export type ManifestEntry = string | string[] | ManifestEntryObj | null;
 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[], {
+export declare function globConfToArgs(conf: GlobConf, cwd: string, localesDir: string, outDir?: string): [string[], {
     ignore: string[];
 }];
 export declare class Files {
@@ -14,7 +22,7 @@ export declare class Files {
     loaderPath: LoaderPath;
     proxyPath: string;
     proxySyncPath: string;
-    constructor(adapter: Adapter, key: string, localesDir: string, root: string);
+    constructor(adapter: Adapter, key: string, localesDir: string, fs: FS, root: string);
     getLoaderPaths(): LoaderPath[];
     getLoaderPath(): Promise<LoaderPath>;
     getCompiledFilePath(loc: string, id: string | null): string;
@@ -23,8 +31,10 @@ export declare class Files {
     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) => Promise<void>;
+    init: (ownerKey: string) => Promise<void>;
     writeUrlFiles: (manifest: URLManifest, fallbackLocale: string) => Promise<void>;
+    getManifestFilePath(id: string | null): string;
+    writeManifest: (keys: ManifestEntry[], id: string | null) => 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;