wuchale 0.22.0 → 0.22.1

package/dist/adapter-vanilla/transformer.js

@@ -417,10 +417,13 @@ export class Transformer {
                 this.heuristciDetails.declaring = 'variable';
             }
         }
+        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 => {

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

@@ -91,16 +91,35 @@ export default class AIQueue {
             const sourceComp = id.map(i => compileTranslation(i, ''));
             for (const loc of batch.targetLocales) {
                 const translation = outItem[loc];
-                if (translation?.length !== 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

@@ -1,4 +1,4 @@
-export declare function toViteError(err: unknown, adapterKey: string, filename: string): never;
+export declare function toViteError(err: any, adapterKey: string, filename: string): Error;
 export declare function trimViteQueries(id: string): string;
 type HotUpdateCtx = {
     file: string;

package/dist/bundlers/vite.js

@@ -1,29 +1,23 @@
 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 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}`;
     }
-    const rendered = typeof err === 'string' ? err : inspect(err, { depth: 5, breakLength: 120, maxStringLength: 10_000 });
-    throw new Error(`${prefix}\n${rendered}`);
+    // 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=');
@@ -37,7 +31,7 @@ export function trimViteQueries(id) {
     return id;
 }
 export const wuchale = (configPath, hmrDelayThreshold = 1000) => {
-    const hub = new Hub(() => getConfig(configPath), dirname(configPath ?? '.'), hmrDelayThreshold);
+    const hub = new Hub(() => getConfig(configPath), dirname(configPath ?? '.'), hmrDelayThreshold, undefined, toViteError);
     return {
         name: pluginName,
         async configResolved(config) {
@@ -54,7 +48,7 @@ export const wuchale = (configPath, hmrDelayThreshold = 1000) => {
                     ctx.server.moduleGraph.invalidateModule(module, invalidatedModules, ctx.timestamp, false);
                 }
             }
-            if (!changeInfo.sourceTriggered) {
+            if (!changeInfo.sourceTriggered && changeInfo.invalidate.size > 0) {
                 ctx.server.ws.send({ type: 'full-reload' });
                 return [];
             }

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

@@ -3,6 +3,7 @@ export type FS = {
     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

@@ -1,4 +1,4 @@
-import { mkdir, readFile, statfs, writeFile } from 'node:fs/promises';
+import { mkdir, readFile, statfs, unlink, writeFile } from 'node:fs/promises';
 export const defaultFS = {
     async read(file) {
         return await readFile(file, 'utf-8');
@@ -21,9 +21,13 @@ export const defaultFS = {
             return false;
         }
     },
+    async unlink(path) {
+        await unlink(path);
+    },
 };
 export const readOnlyFS = {
     ...defaultFS,
     write: () => { },
     mkdir: () => { },
+    unlink: () => { },
 };

package/dist/handler/files.d.ts

@@ -12,7 +12,7 @@ export type ManifestEntryObj = {
 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, cwd: string, localesDir: string, outDir?: string): [string[], {
+export declare function globConfToArgs(conf: GlobConf, root: string, localesDir: string, outDir?: string): [string[], {
     ignore: string[];
 }];
 export declare class Files {

package/dist/handler/files.js

@@ -11,10 +11,10 @@ export function normalizeSep(path) {
     }
     return path.replaceAll('\\', '/');
 }
-export function globConfToArgs(conf, cwd, localesDir, outDir) {
+export function globConfToArgs(conf, root, localesDir, outDir) {
     let patterns = [];
     // ignore generated files
-    const options = { ignore: [localesDir], cwd };
+    const options = { ignore: [`${localesDir}/**/*`], cwd: root };
     if (outDir) {
         options.ignore.push(outDir);
     }
@@ -51,23 +51,23 @@ export class Files {
     proxySyncPath;
     #urlManifestFname;
     #urlsFname;
-    #localesDir;
+    #localesDirAbs;
     #projectRoot;
     constructor(adapter, key, localesDir, fs, root) {
         this.key = key;
         this.#adapter = adapter;
-        this.#localesDir = localesDir;
+        this.#localesDirAbs = resolve(root, localesDir);
         this.#fs = fs;
         this.#projectRoot = root;
     }
     getLoaderPaths() {
-        const loaderPathHead = resolve(this.#localesDir, `${this.key}.loader`);
+        const loaderPathHead = resolve(this.#localesDirAbs, `${this.key}.loader`);
         const paths = [];
         for (const ext of this.#adapter.loaderExts) {
             const pathClient = loaderPathHead + ext;
             const same = { client: pathClient, server: pathClient };
             const diff = { client: pathClient, server: loaderPathHead + '.server' + ext };
-            if (this.#adapter.defaultLoaderPath == null) {
+            if (this.#adapter.defaultLoaderPath === null) {
                 paths.push(diff, same);
             }
             else if (typeof this.#adapter.defaultLoaderPath === 'string') {
@@ -95,6 +95,18 @@ export class Files {
             }
             return path;
         }
+        if (this.#adapter.defaultLoaderPath === null) {
+            const loaderForms = paths
+                .map(p => {
+                let f = `  ${relative(this.#projectRoot, p.client)}`;
+                if (p.server !== p.client) {
+                    f += ` (and ${relative(this.#projectRoot, p.server)})`;
+                }
+                return f;
+            })
+                .join('\n');
+            throw new Error(`Custom loader specified for adapter '${this.key}' but no loader file exists in one of the forms:\n${loaderForms}`);
+        }
         return paths[0];
     }
     #proxyFileName(sync = false) {
@@ -106,14 +118,14 @@ export class Files {
     }
     async #initPaths() {
         this.loaderPath = await this.getLoaderPath();
-        this.proxyPath = resolve(this.#localesDir, generatedDir, this.#proxyFileName());
-        this.proxySyncPath = resolve(this.#localesDir, generatedDir, this.#proxyFileName(true));
-        this.#urlManifestFname = resolve(this.#localesDir, generatedDir, `${this.key}.urls.js`);
-        this.#urlsFname = resolve(this.#localesDir, `${this.key}.url.js`);
+        this.proxyPath = resolve(this.#localesDirAbs, generatedDir, this.#proxyFileName());
+        this.proxySyncPath = resolve(this.#localesDirAbs, generatedDir, this.#proxyFileName(true));
+        this.#urlManifestFname = resolve(this.#localesDirAbs, generatedDir, `${this.key}.urls.js`);
+        this.#urlsFname = resolve(this.#localesDirAbs, `${this.key}.url.js`);
     }
     getCompiledFilePath(loc, id) {
         const ownerKey = this.ownerKey;
-        return resolve(this.#localesDir, generatedDir, `${ownerKey}.${id ?? ownerKey}.${loc}.compiled.js`);
+        return resolve(this.#localesDirAbs, generatedDir, `${ownerKey}.${id ?? ownerKey}.${loc}.compiled.js`);
     }
     getImportPath(filename, importer) {
         const relTo = importer ? resolve(this.#projectRoot, importer) : filename;
@@ -211,7 +223,7 @@ export class Files {
     };
     getManifestFilePath(id) {
         const ownerKey = this.ownerKey;
-        return resolve(this.#localesDir, generatedDir, `${ownerKey}.${id ?? ownerKey}.manifest.js`);
+        return resolve(this.#localesDirAbs, generatedDir, `${ownerKey}.${id ?? ownerKey}.manifest.js`);
     }
     writeManifest = async (keys, id) => {
         const content = `/** @type {(string | {text: string | string[], context?: string, isUrl?: boolean} | null)[]} */\n` +

package/dist/handler/index.js

@@ -85,7 +85,9 @@ export class AdapterHandler {
         await this.sharedState.save();
     };
     compile = async (hmrVersion = -1) => {
-        await Promise.all(this.#config.locales.map(loc => this.#compileForLocale(loc, hmrVersion)));
+        // for proper fallback
+        const localesOrdered = [this.sourceLocale, ...this.#config.locales.filter(l => l !== this.sourceLocale)];
+        await Promise.all(localesOrdered.map(loc => this.#compileForLocale(loc, hmrVersion)));
         await this.#writeManifests();
     };
     #buildManifest = (indices) => {

package/dist/hub.d.ts

@@ -43,9 +43,10 @@ type CheckResult = {
     errors: CheckErrorItem[];
     syncs: string[];
 };
+type TransformErrFormatter = (e: Error, adapterKey: string, filename: string) => Error;
 export declare class Hub {
     #private;
-    constructor(loadConfig: ConfigLoader, root: string, hmrDelayThreshold?: number, fs?: FS);
+    constructor(loadConfig: ConfigLoader, root: string, hmrDelayThreshold?: number, fs?: FS, formatTransformErr?: TransformErrFormatter);
     init: (mode: Mode) => Promise<void>;
     onFileChange: (file: string, read: () => string | Promise<string>) => Promise<FileChangeInfo | undefined>;
     transform: (code: string, filePath: string, forServer?: boolean) => ReturnType<AdapterHandler["transform"]>;

package/dist/hub.js

@@ -6,7 +6,7 @@ import { watch as watchFS } from 'chokidar';
 import {} from 'picomatch';
 import { glob } from 'tinyglobby';
 import { compileTranslation, isEquivalent } from './compile.js';
-import { defaultFS, readOnlyFS } from './fs.js';
+import { defaultFS } from './fs.js';
 import { dataFileName, generatedDir, globConfToArgs, normalizeSep } from './handler/files.js';
 import { AdapterHandler } from './handler/index.js';
 import { SharedState } from './handler/state.js';
@@ -33,20 +33,23 @@ export class Hub {
     #log;
     #mode;
     #loadConfig;
+    #formatTransformErr = e => e;
     #hmrVersion = -1;
     #hmrDelayThreshold;
     #lastSourceTriggeredCatalogWrite = 0;
-    constructor(loadConfig, root, hmrDelayThreshold = 1000, fs = defaultFS) {
+    constructor(loadConfig, root, hmrDelayThreshold = 1000, fs = defaultFS, formatTransformErr) {
         this.#loadConfig = loadConfig;
         this.#fs = fs;
         this.#projectRoot = root;
         // threshold to consider po file change is manual edit instead of a sideeffect of editing code
         this.#hmrDelayThreshold = hmrDelayThreshold;
+        this.#formatTransformErr = formatTransformErr ?? this.#formatTransformErr;
     }
     async #initGenDirWithData() {
-        await this.#fs.mkdir(resolve(this.#config.localesDir, generatedDir));
+        const localesDirAbs = resolve(this.#projectRoot, this.#config.localesDir);
+        await this.#fs.mkdir(resolve(localesDirAbs, generatedDir));
         // data file
-        await this.#fs.write(resolve(this.#config.localesDir, dataFileName), [
+        await this.#fs.write(resolve(localesDirAbs, dataFileName), [
             `/** @typedef {('${this.#config.locales.join("'|'")}')} Locale */`,
             `/** @type {Locale[]} */`,
             `export const locales = ['${this.#config.locales.join("','")}']`,
@@ -105,7 +108,8 @@ export class Hub {
                 }
             }
         }
-        this.#confUpdateFile = normalizeSep(resolve(this.#config.localesDir, generatedDir, confUpdateName));
+        const confUpdateFileAbs = resolve(this.#projectRoot, this.#config.localesDir, generatedDir, confUpdateName);
+        this.#confUpdateFile = normalizeSep(confUpdateFileAbs);
         await this.#fs.write(this.#confUpdateFile, '{}'); // only watch changes so prepare first
     };
     #getSharedState = (adapter, key, sourceLocale, fileMatches) => {
@@ -114,10 +118,8 @@ export class Hub {
             root: this.#projectRoot,
             sourceLocale: sourceLocale,
             haveUrl: adapter.url != null,
+            fs: this.#fs,
         });
-        if (this.#fs === readOnlyFS) {
-            storage.save = async () => { }; // disable writes
-        }
         let sharedState = this.#sharedStates.get(storage.key);
         if (sharedState == null) {
             sharedState = new SharedState(storage, key, sourceLocale);
@@ -132,6 +134,7 @@ export class Hub {
         return sharedState;
     };
     onFileChange = async (file, read) => {
+        file = normalizeSep(file); // just to be sure
         if (this.#confUpdateFile === file) {
             const update = JSON.parse(await read());
             this.#log.info(`${logPrefix} config update received: ${update}`);
@@ -184,7 +187,7 @@ export class Hub {
         if (this.#mode === 'dev' && !this.#config.hmr) {
             return [{}, false];
         }
-        const filename = relative(this.#projectRoot, filePath);
+        const filename = normalizeSep(relative(this.#projectRoot, filePath));
         let output = null;
         let lastAdapterKey = null;
         for (const adapter of this.#handlers.values()) {
@@ -192,7 +195,12 @@ export class Hub {
                 if (lastAdapterKey != null) {
                     throw new Error(`${logPrefix} ${filename} matches both adapters ${lastAdapterKey} and ${adapter.key}`);
                 }
-                output = await adapter.transform(code, filename, this.#hmrVersion, forServer);
+                try {
+                    output = await adapter.transform(code, filename, this.#hmrVersion, forServer);
+                }
+                catch (e) {
+                    throw this.#formatTransformErr(e, adapter.key, filename);
+                }
                 lastAdapterKey = adapter.key;
             }
         }
@@ -240,7 +248,8 @@ export class Hub {
             }
         }
         if (updated) {
-            await handler.sharedState.save();
+            await handler.saveStorage();
+            await handler.compile();
         }
         return updated;
     }
@@ -248,7 +257,11 @@ export class Hub {
         !watch && this.#log.info('Extracting...');
         const handlers = Array.from(this.#handlers.values());
         // owner adapter handlers should run last for cleanup
-        handlers.sort(h => (h.sharedState.ownerKey === h.key ? 1 : -1));
+        handlers.sort((a, b) => {
+            const aOwner = a.sharedState.ownerKey === a.key;
+            const bOwner = b.sharedState.ownerKey === b.key;
+            return aOwner === bOwner ? 0 : aOwner ? 1 : -1;
+        });
         // separate loop to make sure that all otherFileMatchers are collected
         for (const handler of handlers) {
             await this.#directVisitHandler(handler, clean, sync);

package/dist/pofile.d.ts

@@ -1,6 +1,6 @@
 import PO from 'pofile';
 import { type PluralRule, type SaveData, type StorageFactory, type StorageFactoryOpts } from './storage.js';
-type POItem = InstanceType<typeof PO.Item>;
+export type POItem = InstanceType<typeof PO.Item>;
 export type POFileOptions = {
     dir: string;
     separateUrls: boolean;

package/dist/pofile.js

@@ -1,10 +1,17 @@
-import { mkdir } from 'node:fs/promises';
-import { isAbsolute, resolve } from 'node:path';
+import { resolve } from 'node:path';
 import PO from 'pofile';
 import { getKey } from './adapters.js';
 import { deepMergeObjects } from './config.js';
 import { itemIsObsolete, itemIsUrl, } from './storage.js';
 const urlAdapterFlagPrefix = 'url:';
+function join(parts, sep) {
+    return parts.map(s => s.replaceAll('\\', '\\\\').replaceAll(sep, `\\${sep}`)).join(sep);
+}
+function split(str, sep, count) {
+    return str
+        .split(new RegExp(`(?<!\\\\)${sep}`), count)
+        .map(s => s.replaceAll(`\\${sep}`, sep).replaceAll('\\\\', '\\'));
+}
 function itemToPOItem(item, locale, sourceLocale) {
     const poi = new PO.Item();
     const id = item.translations.get(sourceLocale);
@@ -23,9 +30,9 @@ function itemToPOItem(item, locale, sourceLocale) {
             comm.push(frEntry.link);
         }
         for (const [i, ph] of frEntry.placeholders) {
-            comm.push(`${i}: ${ph}`);
+            comm.push(join([String(i), ph], ': '));
         }
-        return comm.join('; ');
+        return join(comm, '; ');
     }))
         .filter(c => c !== null);
     const additionals = item.additionals ?? new Map();
@@ -37,15 +44,7 @@ function itemToPOItem(item, locale, sourceLocale) {
     poi.obsolete = itemIsObsolete(item);
     return poi;
 }
-function getItemId(poi) {
-    const msgid = [poi.msgid];
-    if (poi.msgid_plural) {
-        msgid.push(poi.msgid_plural);
-    }
-    return msgid;
-}
 function poitemToItemCommons(poi) {
-    const msgid = getItemId(poi);
     const references = [];
     let lastRef = { file: '', refs: [] };
     const urlAdapters = [];
@@ -65,7 +64,7 @@ function poitemToItemCommons(poi) {
             continue;
         }
         const refEnt = { placeholders: [] };
-        const commSp = comm.split('; ');
+        const commSp = split(comm, '; ');
         let phStart = 0;
         if (urlAdapters.length) {
             // url
@@ -73,19 +72,51 @@ function poitemToItemCommons(poi) {
             phStart++;
         }
         for (const c of commSp.slice(phStart)) {
-            const [i, ph] = c.split(': ', 2);
+            const [i, ph] = split(c, ': ', 2);
             refEnt.placeholders.push([Number(i), ph]);
         }
         lastRef.refs.push(refEnt);
     }
     return {
-        id: msgid,
         translations: new Map(),
         context: poi.msgctxt,
         references,
         urlAdapters,
     };
 }
+function getItemId(poItem) {
+    const id = [poItem.msgid];
+    if (poItem.msgid_plural) {
+        id.push(poItem.msgid_plural);
+    }
+    return id;
+}
+function poitemsToItems(poItems, locales, sourceLocale) {
+    // then merge them
+    const items = [];
+    for (const poIs of poItems) {
+        const basePoOtem = poIs.values().next().value;
+        const item = poitemToItemCommons(basePoOtem);
+        const additionals = new Map();
+        for (const loc of locales) {
+            const poi = poIs.get(loc);
+            item.translations.set(loc, poi?.msgstr ?? (loc === sourceLocale ? getItemId(basePoOtem) : []));
+            const add = {
+                comments: poi?.comments ?? [],
+                flags: {},
+            };
+            for (const [k, v] of Object.entries(poi?.flags ?? {})) {
+                if (!k.startsWith(urlAdapterFlagPrefix)) {
+                    add.flags[k] = v;
+                }
+            }
+            additionals.set(loc, add);
+        }
+        item.additionals = additionals;
+        items.push(item);
+    }
+    return items;
+}
 export const defaultOpts = {
     dir: 'src/locales',
     separateUrls: true,
@@ -96,11 +127,9 @@ export class POFile {
     filesByLoc = new Map(); // main and url
     files = [];
     constructor(opts) {
-        this.key = opts.dir;
         this.opts = opts;
-        if (!isAbsolute(opts.dir)) {
-            opts.dir = resolve(opts.root, opts.dir);
-        }
+        opts.dir = resolve(opts.root, opts.dir);
+        this.key = opts.dir;
         for (const locale of opts.locales) {
             const locFiles = [resolve(opts.dir, `${locale}.po`), resolve(opts.dir, `${locale}.url.po`)];
             this.filesByLoc.set(locale, locFiles);
@@ -110,16 +139,7 @@ export class POFile {
     async loadRaw(locale, url) {
         const filename = this.filesByLoc.get(locale)[Number(url)];
         try {
-            return await new Promise((res, rej) => {
-                PO.load(filename, (err, po) => {
-                    if (err) {
-                        rej(err);
-                    }
-                    else {
-                        res(po);
-                    }
-                });
-            });
+            return PO.parse(await this.opts.fs.read(filename));
         }
         catch (err) {
             if (err.code !== 'ENOENT') {
@@ -156,46 +176,24 @@ export class POFile {
                 poItems.get(key)?.set(locale, poItem);
             }
         }
-        // then merge them
-        const items = [];
-        for (const poIs of poItems.values()) {
-            const item = poitemToItemCommons(poIs.get(this.opts.sourceLocale));
-            const additionals = new Map();
-            for (const loc of this.opts.locales) {
-                const poi = poIs.get(loc);
-                item.translations.set(loc, poi?.msgstr ?? []);
-                const add = {
-                    comments: poi?.comments ?? [],
-                    flags: {},
-                };
-                for (const [k, v] of Object.entries(poi?.flags ?? {})) {
-                    if (!k.startsWith(urlAdapterFlagPrefix)) {
-                        add.flags[k] = v;
-                    }
-                }
-                additionals.set(loc, add);
-            }
-            item.additionals = additionals;
-            items.push(item);
-        }
-        return { items, pluralRules };
+        return {
+            items: poitemsToItems(poItems.values(), this.opts.locales, this.opts.sourceLocale),
+            pluralRules,
+        };
     }
     async saveRaw(items, headers, locale, url) {
+        const filename = this.filesByLoc.get(locale)[Number(url)];
+        if (items.length === 0) {
+            if (await this.opts.fs.exists(filename)) {
+                await this.opts.fs.unlink(filename);
+            }
+            return;
+        }
         const po = new PO();
         po.headers = headers;
         po.items = items;
-        const filename = this.filesByLoc.get(locale)[Number(url)];
-        await mkdir(this.opts.dir, { recursive: true });
-        await new Promise((res, rej) => {
-            po.save(filename, err => {
-                if (err) {
-                    rej(err);
-                }
-                else {
-                    res();
-                }
-            });
-        });
+        await this.opts.fs.mkdir(this.opts.dir);
+        await this.opts.fs.write(filename, po.toString());
     }
     async save(data) {
         for (const locale of this.opts.locales) {
@@ -212,9 +210,7 @@ export class POFile {
             }
             const headers = this.getHeaders(locale, data.pluralRules.get(locale));
             await this.saveRaw(poItems, headers, locale, false);
-            if (poItemsUrl.length > 0) {
-                await this.saveRaw(poItemsUrl, headers, locale, true);
-            }
+            await this.saveRaw(poItemsUrl, headers, locale, true);
         }
     }
     getHeaders(locale, pluralRule) {

package/dist/runtime.js

@@ -49,22 +49,17 @@ export default function toRuntime(mod = { [catalogVarName]: [] }, locale) {
     /** for tagged template strings */
     rt.t = (tag, id, args) => {
         const ctx = getCompositeContext(id);
-        const strings = [];
+        const strings = [''];
         const exprs = [];
-        if (typeof ctx[0] === 'number') {
-            strings.push('');
-        }
         for (const x of ctx) {
             if (typeof x === 'string') {
-                strings.push(x);
+                strings[strings.length - 1] += x;
                 continue;
             }
             exprs.push(args?.[x]);
-        }
-        if (typeof ctx.at(-1) === 'number') {
             strings.push('');
         }
-        return tag(strings, ...exprs);
+        return tag(Object.assign(strings, { raw: strings }), ...exprs);
     };
     /** get translation for plural */
     rt.p = (id) => catalog[id] ?? [];

package/dist/storage.d.ts

@@ -1,3 +1,4 @@
+import type { FS } from './fs.js';
 export type FileRefEntry = {
     link?: string;
     placeholders: [number, string][];
@@ -54,5 +55,6 @@ export type StorageFactoryOpts = {
     /** whether the url is configured, can use to load separate url files */
     haveUrl: boolean;
     sourceLocale: string;
+    fs: FS;
 };
 export type StorageFactory = (opts: StorageFactoryOpts) => CatalogStorage;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "wuchale",
-    "version": "0.22.0",
+    "version": "0.22.1",
     "description": "Protobuf-like i18n from plain code",
     "scripts": {
         "dev": "tsc --watch",