wuchale 0.21.2 → 0.22.1

package/dist/adapter-vanilla/transformer.js

@@ -113,7 +113,7 @@ 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) => ({
@@ -408,19 +408,23 @@ export class Transformer {
         if (!node.init) {
             return [];
         }
+        const init = this.getActualExpression(node.init);
         if (topLevel) {
-            const init = this.getActualExpression(node.init);
-            if (init?.type === 'ArrowFunctionExpression' || init?.type === 'FunctionExpression') {
+            if (init.type === 'ArrowFunctionExpression' || init.type === 'FunctionExpression') {
                 this.heuristciDetails.declaring = 'function';
             }
             else {
                 this.heuristciDetails.declaring = 'variable';
-                if (init?.type === 'CallExpression') {
-                    this.heuristciDetails.topLevelCall = this.getCalleeName(init.callee);
-                }
             }
         }
-        return [...this.visit(node.id), ...this.visit(node.init)];
+        this.heuristciDetails.leftSide = true;
+        const msgs = this.visit(node.id);
+        this.heuristciDetails.leftSide = false;
+        if (topLevel && this.heuristciDetails.declaring === 'variable' && init.type === 'CallExpression') {
+            this.heuristciDetails.topLevelCall = this.getCalleeName(init.callee);
+        }
+        delete this.heuristciDetails.leftSide;
+        return [...msgs, ...this.visit(node.init)];
     });
     visitExpressionStatement = (node) => this.withUpdateTLDetails(topLevel => {
         const expr = this.getActualExpression(node.expression);

package/dist/adapters.d.ts

@@ -9,11 +9,19 @@ export type HeuristicDetailsBase = {
 export type ScriptDeclType = 'variable' | 'function' | 'class' | 'expression';
 export type HeuristicDetails = HeuristicDetailsBase & {
     file: string;
+    /** the type of the top level declaration */
     declaring?: ScriptDeclType;
+    /** in assignments, whether the string is on the left side as destructuring default */
+    leftSide?: boolean;
+    /** the name of the function being defined, '' for arrow or null for global */
     funcName?: string | null;
+    /** whether the function being defined is nested inside another, null for no function */
     funcIsNested?: boolean;
+    /** whether inside a script file/<script> instead of an expression inside markup */
     insideProgram: boolean;
+    /** the name of the call at the top level */
     topLevelCall?: string;
+    /** the name of the nearest call (for arguments) */
     call?: string;
 };
 export type MessageType = 'message' | 'url';

package/dist/ai/index.js

@@ -87,19 +87,39 @@ 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 === undefined) {
                     unTranslated.push(item);
                     break;
                 }
+                if (id.length > 1) {
+                    // plural
+                    if (translation.length === 0) {
+                        // TODO: pass pluralRule and check nplurals
+                        unTranslated.push(item);
+                        break;
+                    }
+                    item.translations.set(loc, translation);
+                    continue;
+                }
+                if (translation.length !== id.length) {
+                    unTranslated.push(item);
+                    break;
+                }
+                let equivalent = true;
                 for (const [i, sou] of sourceComp.entries()) {
                     if (!isEquivalent(sou, compileTranslation(translation[i], ''))) {
-                        unTranslated.push(item);
+                        equivalent = false;
                         break;
                     }
                 }
+                if (!equivalent) {
+                    unTranslated.push(item);
+                    break;
+                }
                 item.translations.set(loc, translation);
             }
         }

package/dist/bundlers/vite.d.ts

@@ -0,0 +1,32 @@
+export declare function toViteError(err: any, adapterKey: string, filename: string): Error;
+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,64 @@
+import { dirname } from 'node:path';
+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.
+    const frame = typeof err.frame === 'string' ? err.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 (err.id == null)
+        err.id = filename;
+    if (err.loc == null && err.start?.line != null && err.start?.column != null) {
+        err.loc = { file: filename, line: err.start.line, column: err.start.column };
+    }
+    return err;
+}
+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, undefined, toViteError);
+    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 && changeInfo.invalidate.size > 0) {
+                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/compile.js

@@ -77,7 +77,7 @@ function compile(msgStr, start = 0, parentTag = null) {
         if (type === CLOSE) {
             if (currentOpenTag != null) {
                 if (currentOpenTag != n) {
-                    throw Error('Closing a different tag');
+                    return [compiled, 0, 'Closing a different tag'];
                 }
                 currentOpenTag = null;
             }
@@ -85,7 +85,7 @@ function compile(msgStr, start = 0, parentTag = null) {
                 break;
             }
             else {
-                throw Error('Closing a different tag');
+                return [compiled, 0, 'Closing a different tag'];
             }
         }
         else if (type === SELF_CLOSE) {
@@ -100,24 +100,24 @@ function compile(msgStr, start = 0, parentTag = null) {
     if (curTxt) {
         compiled.push(curTxt);
     }
-    return [compiled, i];
+    if (currentOpenTag !== null) {
+        return [compiled, 0, 'Unexpected end'];
+    }
+    return [compiled, i, null];
 }
 export function compileTranslation(msgStr, fallback) {
     if (!msgStr) {
         return fallback;
     }
-    try {
-        const [compiled] = compile(msgStr);
-        if (compiled.length === 1 && typeof compiled[0] === 'string') {
-            return compiled[0];
-        }
-        return compiled;
-    }
-    catch (err) {
-        console.error(err);
-        console.error(msgStr);
+    const [compiled, , err] = compile(msgStr);
+    if (err !== null) {
+        console.error('Compile error:', err, ':', msgStr);
         return fallback;
     }
+    if (compiled.length === 1 && typeof compiled[0] === 'string') {
+        return compiled[0];
+    }
+    return compiled;
 }
 export function isEquivalent(source, translation) {
     const sourceStr = typeof source === 'string';

package/dist/fs.d.ts

@@ -0,0 +1,9 @@
+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>;
+    unlink(path: string): void | Promise<void>;
+};
+export declare const defaultFS: FS;
+export declare const readOnlyFS: FS;

package/dist/fs.js

@@ -0,0 +1,33 @@
+import { mkdir, readFile, statfs, unlink, 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;
+        }
+    },
+    async unlink(path) {
+        await unlink(path);
+    },
+};
+export const readOnlyFS = {
+    ...defaultFS,
+    write: () => { },
+    mkdir: () => { },
+    unlink: () => { },
+};

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, root: 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;