wuchale 0.21.2 → 0.22.0

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,20 @@ 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)];
+        const msgs = this.visit(node.id);
+        if (topLevel && this.heuristciDetails.declaring === 'variable' && init.type === 'CallExpression') {
+            this.heuristciDetails.topLevelCall = this.getCalleeName(init.callee);
+        }
+        return [...msgs, ...this.visit(node.init)];
     });
     visitExpressionStatement = (node) => this.withUpdateTLDetails(topLevel => {
         const expr = this.getActualExpression(node.expression);

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;

package/dist/handler/files.js

@@ -1,9 +1,8 @@
-import { mkdir, readFile, statfs, writeFile } from 'node:fs/promises';
 import { dirname, relative, resolve } from 'node:path';
 import { platform } from 'node:process';
 import { catalogVarName } from '../runtime.js';
 import {} from '../url.js';
-const dataFileName = 'data.js';
+export const dataFileName = 'data.js';
 export const generatedDir = '.wuchale';
 export const objKeyLocale = (locale) => (locale.includes('-') ? `'${locale}'` : locale);
 export function normalizeSep(path) {
@@ -12,10 +11,10 @@ export function normalizeSep(path) {
     }
     return path.replaceAll('\\', '/');
 }
-export function globConfToArgs(conf, localesDir, outDir) {
+export function globConfToArgs(conf, cwd, localesDir, outDir) {
     let patterns = [];
     // ignore generated files
-    const options = { ignore: [localesDir] };
+    const options = { ignore: [localesDir], cwd };
     if (outDir) {
         options.ignore.push(outDir);
     }
@@ -45,6 +44,7 @@ export class Files {
     key;
     ownerKey;
     #adapter;
+    #fs;
     // paths
     loaderPath;
     proxyPath;
@@ -53,10 +53,11 @@ export class Files {
     #urlsFname;
     #localesDir;
     #projectRoot;
-    constructor(adapter, key, localesDir, root) {
+    constructor(adapter, key, localesDir, fs, root) {
         this.key = key;
         this.#adapter = adapter;
         this.#localesDir = localesDir;
+        this.#fs = fs;
         this.#projectRoot = root;
     }
     getLoaderPaths() {
@@ -84,13 +85,7 @@ export class Files {
         for (const path of paths) {
             let bothExist = true;
             for (const side in path) {
-                try {
-                    await statfs(path[side]);
-                }
-                catch (err) {
-                    if (err.code !== 'ENOENT') {
-                        throw err;
-                    }
+                if (!(await this.#fs.exists(path[side]))) {
                     bothExist = false;
                     break;
                 }
@@ -169,19 +164,12 @@ export class Files {
         return this.genProxyContent(object, loadIDs, imports);
     }
     writeProxies = async (locales, loadIDs, loadIDsImport) => {
-        await writeFile(this.proxyPath, this.genProxy(locales, loadIDs, loadIDsImport));
-        await writeFile(this.proxySyncPath, this.genProxySync(locales, loadIDs, loadIDsImport));
+        await this.#fs.write(this.proxyPath, this.genProxy(locales, loadIDs, loadIDsImport));
+        await this.#fs.write(this.proxySyncPath, this.genProxySync(locales, loadIDs, loadIDsImport));
     };
-    init = async (locales, ownerKey) => {
+    init = async (ownerKey) => {
         this.ownerKey = ownerKey;
         await this.#initPaths();
-        await mkdir(resolve(this.#localesDir, generatedDir), { recursive: true });
-        // data file
-        await writeFile(resolve(this.#localesDir, dataFileName), [
-            `/** @typedef {('${locales.join("'|'")}')} Locale */`,
-            `/** @type {Locale[]} */`,
-            `export const locales = ['${locales.join("','")}']`,
-        ].join('\n'));
         if (this.#adapter.defaultLoaderPath == null) {
             // using custom loaders
             return;
@@ -194,13 +182,13 @@ export class Files {
             else {
                 loaderTemplate = this.#adapter.defaultLoaderPath[side];
             }
-            const loaderContent = (await readFile(loaderTemplate))
+            const loaderContent = (await this.#fs.read(loaderTemplate))
                 .toString()
                 .replaceAll('${PROXY}', `./${generatedDir}/${this.#proxyFileName()}`)
                 .replaceAll('${PROXY_SYNC}', `./${generatedDir}/${this.#proxyFileName(true)}`)
                 .replaceAll('${DATA}', `./${dataFileName}`)
                 .replaceAll('${KEY}', this.key);
-            await writeFile(this.loaderPath[side], loaderContent);
+            await this.#fs.write(this.loaderPath[side], loaderContent);
         }
     };
     writeUrlFiles = async (manifest, fallbackLocale) => {
@@ -211,7 +199,7 @@ export class Files {
             `/** @type {import('wuchale/url').URLManifest} */`,
             `export default ${JSON.stringify(manifest)}`,
         ].join('\n');
-        await writeFile(this.#urlManifestFname, urlManifestData);
+        await this.#fs.write(this.#urlManifestFname, urlManifestData);
         const urlFileContent = [
             'import {URLMatcher, deLocalizeDefault} from "wuchale/url"',
             `import {locales} from "./${dataFileName}"`,
@@ -219,7 +207,16 @@ export class Files {
             `export const getLocale = (/** @type {URL} */ url) => deLocalizeDefault(url.pathname, locales)[1] ?? '${fallbackLocale}'`,
             `export const matchUrl = URLMatcher(manifest, locales)`,
         ].join('\n');
-        await writeFile(this.#urlsFname, urlFileContent);
+        await this.#fs.write(this.#urlsFname, urlFileContent);
+    };
+    getManifestFilePath(id) {
+        const ownerKey = this.ownerKey;
+        return resolve(this.#localesDir, generatedDir, `${ownerKey}.${id ?? ownerKey}.manifest.js`);
+    }
+    writeManifest = async (keys, id) => {
+        const content = `/** @type {(string | {text: string | string[], context?: string, isUrl?: boolean} | null)[]} */\n` +
+            `export const keys = ${JSON.stringify(keys)}`;
+        await this.#fs.write(this.getManifestFilePath(id), content);
     };
     writeCatalogModule = async (compiledData, pluralRule, locale, hmrVersion, loadID) => {
         const compiledItems = JSON.stringify(compiledData);
@@ -244,15 +241,15 @@ export class Files {
                 }
             `;
         }
-        await writeFile(this.getCompiledFilePath(locale, loadID), module);
+        await this.#fs.write(this.getCompiledFilePath(locale, loadID), module);
     };
     writeTransformed = async (filename, content) => {
         if (!this.#adapter.outDir) {
             return;
         }
         const fname = resolve(this.#adapter.outDir + '/' + filename);
-        await mkdir(dirname(fname), { recursive: true });
-        await writeFile(fname, content);
+        await this.#fs.mkdir(dirname(fname));
+        await this.#fs.write(fname, content);
     };
     getImportLoaderPath(forServer, relativeTo) {
         return this.getImportPath(forServer ? this.loaderPath.server : this.loaderPath.client, relativeTo);

package/dist/handler/index.d.ts

@@ -2,10 +2,11 @@ import { type Matcher } from 'picomatch';
 import type { Adapter, Message, TransformOutputCode } from '../adapters.js';
 import { type CompiledElement } from '../compile.js';
 import type { ConfigPartial } from '../config.js';
+import type { FS } from '../fs.js';
 import type { Logger } from '../log.js';
 import { type FileRef, type Item } from '../storage.js';
 import { Files } from './files.js';
-import { type SharedState, SharedStates, State } from './state.js';
+import { type SharedState, State } from './state.js';
 import { URLHandler } from './url.js';
 export type Mode = 'dev' | 'build' | 'cli';
 type TrackedRefs = Map<string, {
@@ -16,19 +17,18 @@ export declare class AdapterHandler {
     #private;
     key: string;
     /** config.locales and adapter's sourceLocale */
-    allLocales: string[];
-    sourceLocale: string;
+    readonly sourceLocale: string;
+    readonly adapter: Adapter;
     fileMatches: Matcher;
     sharedState: SharedState;
     granularState: State;
     files: Files;
     url: URLHandler;
     onBeforeSave: () => void;
-    constructor(adapter: Adapter, key: string, config: ConfigPartial, mode: Mode, projectRoot: string, log: Logger);
+    constructor(adapter: Adapter, key: string, config: ConfigPartial, mode: Mode, fs: FS, projectRoot: string, log: Logger);
     /** return two arrays: the corresponding one, and the one to import from in the case of shared catalogs */
     getLoadIDs(): [string[], string[]];
-    initSharedState: (sharedStates: SharedStates) => void;
-    init: (sharedStates: SharedStates) => Promise<void>;
+    init: (sharedState: SharedState) => Promise<void>;
     loadStorage: () => Promise<void>;
     saveStorage: () => Promise<void>;
     compile: (hmrVersion?: number) => Promise<void>;