wuchale 0.23.3 → 0.24.0

package/dist/adapters.d.ts

@@ -22,13 +22,16 @@ export type HeuristicDetails = HeuristicDetailsBase & {
     topLevelCall?: string | undefined;
     /** the name of the nearest call (for arguments) */
     call?: string | undefined;
+    /** inside an export const ... etc */
+    exported?: boolean | undefined;
+    /** object property path */
+    property?: string | undefined;
 };
 export type MessageType = 'message' | 'url';
 export type Message = {
     msgStr: string[];
-    plural: boolean;
     context?: string | undefined;
-    placeholders: [number, string][];
+    placeholders: [string, string][];
     details: HeuristicDetails;
     type: MessageType;
 };
@@ -43,6 +46,7 @@ export declare const defaultHeuristicOpts: {
     ignoreCalls: string[];
     urlAttribs: string[][];
     urlCalls: string[];
+    urlProps: string[];
 };
 export type CreateHeuristicOpts = typeof defaultHeuristicOpts;
 export declare function createHeuristic(opts: CreateHeuristicOpts): HeuristicFunc;
@@ -50,11 +54,12 @@ export declare function createHeuristic(opts: CreateHeuristicOpts): HeuristicFun
 export declare const defaultHeuristic: HeuristicFunc;
 /** Default heuristic which ignores messages outside functions in the `script` scope */
 export declare const defaultHeuristicFuncOnly: HeuristicFunc;
-export declare const defaultGenerateLoadID: (filename: string) => string;
 export declare class IndexTracker {
-    indices: Map<string, number>;
-    nextIndex: number;
+    #private;
+    constructor(bypassHas: boolean);
     get: (msgStr: string) => number;
+    has: (msgStr: string) => boolean;
+    getAll: () => MapIterator<[string, number]>;
 }
 export type GlobConf = string | string[] | {
     include: string | string[];
@@ -64,8 +69,8 @@ export type RuntimeExpr = {
     plain: string;
     reactive: string;
 };
-export type UrlMatcher = (url: string) => string | null | undefined;
-type TransformCtx = {
+export type UrlMatcher = (url: string) => readonly [number, string[]] | null;
+export type TransformCtx = {
     content: string;
     filename: string;
     index: IndexTracker;
@@ -109,16 +114,17 @@ export type URLConf = {
     patterns?: string[];
     localize?: boolean | string;
 };
+export type LoadGroupPatt = string | string[];
 export type AdapterPassThruOpts = {
     sourceLocale?: string;
     files: GlobConf;
     storage: StorageFactory;
-    /** if writing transformed code to a directory is desired, specify this */
-    outDir?: string;
-    granularLoad: boolean;
-    bundleLoad: boolean;
+    loading: {
+        direct: boolean;
+        granular: boolean;
+        group: LoadGroupPatt[];
+    };
     url?: URLConf;
-    generateLoadID: (filename: string) => string;
     runtime: RuntimeConf;
 };
 export type Adapter = AdapterPassThruOpts & {

package/dist/adapters.js

@@ -5,7 +5,6 @@ export function newMessage(init) {
     }
     return {
         msgStr: init.msgStr,
-        plural: init.plural ?? false,
         placeholders: init.placeholders ?? [],
         type: init.type ?? 'message',
         context: init.context,
@@ -23,6 +22,7 @@ export const defaultHeuristicOpts = {
     ignoreCalls: ['fetch'],
     urlAttribs: [['a', 'href']],
     urlCalls: [],
+    urlProps: ['href', 'link', 'url'],
 };
 export function createHeuristic(opts) {
     return msg => {
@@ -46,6 +46,13 @@ export function createHeuristic(opts) {
                     }
                 }
             }
+            if (msg.details.property) {
+                for (const prop of opts.urlProps) {
+                    if (msg.details.property === prop || msg.details.property?.endsWith(`.${prop}`)) {
+                        return 'url';
+                    }
+                }
+            }
             if (msg.details.attribute) {
                 for (const [element, attrib] of opts.urlAttribs) {
                     if (msg.details.element === element && msg.details.attribute === attrib) {
@@ -61,11 +68,19 @@ export function createHeuristic(opts) {
             return 'message';
         }
         // script and attribute
-        // ignore:
-        //  non-letter beginnings
-        //  lower-case English letter beginnings
-        //  containing only upper-case English and non-letters
-        if (!/\p{L}/u.test(msgStr[0]) || /[a-z]/.test(msgStr[0]) || /^([A-Z]|\P{L})+$/u.test(msgStr)) {
+        if (/^([A-Z]|\P{L})+$/u.test(msgStr)) {
+            // only upper-case English and non-letters
+            return false;
+        }
+        if (/^\{\d+\}/.test(msgStr)) {
+            // template literals that begin with a placeholder expression
+            if (!/\s\p{L}/u.test(msgStr)) {
+                // should contain spaces and letters
+                return false;
+            }
+        }
+        else if (/[a-z]|\P{L}/u.test(msgStr[0])) {
+            // ignore non-letter and lower-case English beginnings
             return false;
         }
         if (msg.details.scope === 'attribute') {
@@ -90,18 +105,23 @@ export const defaultHeuristicFuncOnly = msg => {
     }
     return false;
 };
-export const defaultGenerateLoadID = (filename) => filename.replace(/[^a-zA-Z0-9_]+/g, '_');
 export class IndexTracker {
-    indices = new Map();
-    nextIndex = 0;
+    #indices = new Map();
+    #nextIndex = 0;
+    #bypassHas;
+    constructor(bypassHas) {
+        this.#bypassHas = bypassHas;
+    }
     get = (msgStr) => {
-        let index = this.indices.get(msgStr);
+        let index = this.#indices.get(msgStr);
         if (index != null) {
             return index;
         }
-        index = this.nextIndex;
-        this.indices.set(msgStr, index);
-        this.nextIndex++;
+        index = this.#nextIndex;
+        this.#indices.set(msgStr, index);
+        this.#nextIndex++;
         return index;
     };
+    has = (msgStr) => this.#bypassHas || this.#indices.has(msgStr);
+    getAll = () => this.#indices.entries();
 }

package/dist/ai/gemini.js

@@ -15,7 +15,7 @@ function prepareData(content, instruction, think) {
             },
     };
 }
-export function gemini({ apiKey = 'env', model = 'gemini-2.5-flash', group = {}, batchSize = 50, think = false, parallel = 4, } = {}) {
+export function gemini({ apiKey = 'env', model = 'gemini-3.5-flash', group = {}, batchSize = 50, think = false, parallel = 4, } = {}) {
     if (apiKey === 'env') {
         apiKey = process.env['GEMINI_API_KEY'] ?? '';
     }

package/dist/ai/index.js

@@ -43,7 +43,9 @@ Respond with a JSON array matching the order of the input items. Each element is
 Output schema:
 ${JSON.stringify(outputSchema)}
 
-Respond ONLY with raw compact JSON. Do not wrap it in markdown code fences or add any other text.
+CRITICAL!:
+- ALWAYS Respond with a raw compact JSON array even if there is only one item.
+- NEVER wrap it in markdown code fences or any other surrounding text.
 `.trim();
 // implements a queue for a sequential translation useful for vite's transform during dev
 // as vite can do async transform

package/dist/bundlers/vite.d.ts

@@ -31,7 +31,7 @@ export declare const wuchale: ({ configPath, hmrDelayThreshold, trimQueryParams
         order: "pre";
         handler(code: string, id: string, options?: {
             ssr?: boolean | undefined;
-        }): Promise<import("wuchale").TransformOutputCode>;
+        }): Promise<import("../adapters.js").TransformOutputCode>;
     };
 };
 export {};

package/dist/bundlers/vite.js

@@ -1,5 +1,5 @@
 import { dirname } from 'node:path';
-import { getConfig } from 'wuchale';
+import { getConfig } from '../config.js';
 import { Hub, pluginName } from '../hub.js';
 export function toViteError(err, adapterKey, filename) {
     const prefix = `${adapterKey}: transform failed for ${filename}`;
@@ -49,11 +49,11 @@ export function trimViteQueries(id, trimParams) {
 }
 export const wuchale = ({ configPath, hmrDelayThreshold = 1000, trimQueryParams } = {}) => {
     let hub;
-    const trimParams = new Set([...(trimQueryParams ?? []), 'v', 't', 'sentry-auto-wrap']);
+    const trimParams = new Set([...(trimQueryParams ?? []), 'v', 't', 'sentry-auto-wrap', 'tsr-split']);
     return {
         name: pluginName,
         async configResolved(config) {
-            hub = await Hub.create(config.env.DEV ? 'dev' : 'build', () => getConfig(configPath), dirname(configPath ?? '.'), hmrDelayThreshold, undefined, toViteError);
+            hub = await Hub.create(config.env.DEV ? 'dev' : 'build', () => getConfig(configPath), dirname(configPath ?? '.'), [], hmrDelayThreshold, undefined, toViteError);
         },
         async handleHotUpdate(ctx) {
             const changeInfo = await hub.onFileChange(ctx.file, ctx.read);

package/dist/cli/check.js

@@ -15,7 +15,7 @@ const checkErrMsgs = {
 };
 export async function check(config, root, full) {
     // disable ai as this is a check, not persisted
-    const hub = await Hub.create('cli', () => ({ ...config, ai: null }), root, 0, readOnlyFS);
+    const hub = await Hub.create('cli', () => ({ ...config, ai: null }), root, [], 0, readOnlyFS);
     const { checked, errors, syncs } = await hub.check(full);
     // console.log because if the user invokes this command, they want full info regardless of config
     for (const err of errors) {

package/dist/cli/index.js

@@ -38,6 +38,9 @@ const { positionals, values } = parseArgs({
             short: 'l',
             default: 'info',
         },
+        modify: {
+            type: 'string',
+        },
         help: {
             type: 'boolean',
             short: 'h',
@@ -57,10 +60,11 @@ Commands:
     ${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')}      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('--config')}         Use another config file instead of ${defaultConfigNames.map(color.cyan).join('|')}
+    ${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('--modify a1,a2')}   Modify files in place for adapters ${color.cyan('a1')}, ${color.cyan('a2')}, etc.
     ${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
 
@@ -96,7 +100,10 @@ else if (values.help) {
 }
 else if (cmd == null) {
     const [config, root] = await configRootLocales();
-    const hub = await Hub.create('cli', () => config, root);
+    const hub = await Hub.create('cli', () => config, root, values.modify
+        ?.split(',')
+        ?.map(a => a.trim())
+        ?.filter(a => a) ?? []);
     await hub.directVisit(values.clean, values.watch, values.sync);
 }
 else {

package/dist/cli/status.js

@@ -13,7 +13,7 @@ Options:
 `;
 export async function status(config, root, json) {
     // console.log because if the user invokes this command, they want full info regardless of config
-    const hub = await Hub.create('cli', () => config, root, 0, readOnlyFS);
+    const hub = await Hub.create('cli', () => config, root, [], 0, readOnlyFS);
     if (json) {
         console.log(JSON.stringify(await hub.status(), null, process.stdout.isTTY ? '  ' : undefined));
         return;

package/dist/config.d.ts

@@ -8,9 +8,10 @@ export type ConfigPartial = {
     ai: AI | null;
     logLevel: LogLevel;
 };
+export type DevMode = false | 'read' | 'add' | 'refs' | 'clean';
 export type Config = ConfigPartial & {
     adapters: Record<string, Adapter>;
-    hmr: boolean;
+    dev: DevMode;
 };
 export type DeepPartial<T> = {
     [K in keyof T]?: T[K] extends (infer A)[] ? DeepPartial<A>[] : T[K] extends (...args: any[]) => any ? T[K] : T[K] extends object ? DeepPartial<T[K]> : T[K];

package/dist/config.js

@@ -5,14 +5,14 @@ export const defaultConfig = {
     fallback: {},
     localesDir: 'src/locales',
     adapters: {},
-    hmr: true,
+    dev: 'refs',
     ai: defaultGemini,
     logLevel: 'info',
 };
 function deepFill(target, defaults) {
     for (const [key, def] of Object.entries(defaults)) {
         const value = target[key];
-        if (Array.isArray(value)) {
+        if (value !== undefined && (typeof value !== 'object' || Array.isArray(value))) {
             continue;
         }
         if (!def || Array.isArray(def) || typeof def !== 'object') {

package/dist/handler/files.d.ts

@@ -1,9 +1,10 @@
-import type { Adapter, GlobConf, LoaderPath } from '../adapters.js';
+import type { Adapter, GlobConf, LoaderPath, LoadGroupPatt } 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 declare const defaultLoadID = 0;
 export type ManifestEntryObj = {
     text: string | string[];
     context?: string | undefined;
@@ -22,25 +23,22 @@ export type FilesOptsCreate = FilesOptsCreatePass & {
 };
 export declare const objKeyLocale: (locale: string) => string;
 export declare function normalizeSep(path: string): string;
-export declare function globConfToArgs(conf: GlobConf, root: string, localesDir: string, outDir?: string): [string[], {
-    ignore: string[];
-}];
+export declare function globConfToArgs(conf: GlobConf, localesDir: string): [string[], string[]];
 export declare function getLoaderPath(adapter: Adapter, key: string, localesDirAbs: string, root: string, fs: FS): Promise<LoaderPath>;
 export declare class Files {
     #private;
     readonly loaderPath: LoaderPath;
     private constructor();
-    getCompiledFilePath(loc: string, id: string | null): string;
+    getCompiledFilePath(loc: string, id: number | null): string;
     getImportPath(filename: string, importer?: string): string;
-    genProxyContent(catalogs: string[], loadIDs: string[], syncImports?: string[]): string;
-    genProxy(locales: string[], loadIDs: string[], loadIDsImport: string[]): string;
-    genProxySync(locales: string[], loadIDs: string[], loadIDsImport: string[]): string;
-    writeProxies: (locales: string[], loadIDs: string[], loadIDsImport: string[]) => Promise<void>;
+    genProxyContent(catalogs: string[], patterns: LoadGroupPatt[], locales: string[], syncImports?: string[]): string;
+    genProxy(locales: string[], patterns: LoadGroupPatt[]): string;
+    genProxySync(locales: string[], patterns: LoadGroupPatt[]): string;
+    writeProxies: (locales: string[], groupPatterns: LoadGroupPatt[]) => Promise<void>;
     static create: (opts: FilesOptsCreate) => Promise<Files>;
     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>;
+    getManifestFilePath(id: number | null): string;
+    writeManifest: (keys: ManifestEntry[], id: number | null) => Promise<void>;
+    writeCatalogModule: (compiledData: CompiledElement[], pluralRule: string | null, locale: string, hmrVersion: number | null, loadID: number | null) => Promise<void>;
     getImportLoaderPath(forServer: boolean, relativeTo: string): string;
 }

package/dist/handler/files.js

@@ -2,6 +2,7 @@ import { dirname, relative, resolve } from 'node:path';
 import { platform } from 'node:process';
 export const dataFileName = 'data.js';
 export const generatedDir = '.wuchale';
+export const defaultLoadID = 0;
 export const objKeyLocale = (locale) => (locale.includes('-') ? `'${locale}'` : locale);
 export function normalizeSep(path) {
     if (platform !== 'win32') {
@@ -9,13 +10,10 @@ export function normalizeSep(path) {
     }
     return path.replaceAll('\\', '/');
 }
-export function globConfToArgs(conf, root, localesDir, outDir) {
+export function globConfToArgs(conf, localesDir) {
     let patterns = [];
     // ignore generated files
-    const options = { ignore: [`${localesDir}/**/*`], cwd: root };
-    if (outDir) {
-        options.ignore.push(outDir);
-    }
+    const ignore = [`${localesDir}/**/*`];
     if (typeof conf === 'string') {
         patterns = [conf];
     }
@@ -30,13 +28,13 @@ export function globConfToArgs(conf, root, localesDir, outDir) {
             patterns = conf.include;
         }
         if (typeof conf.ignore === 'string') {
-            options.ignore.push(conf.ignore);
+            ignore.push(conf.ignore);
         }
         else {
-            options.ignore.push(...conf.ignore);
+            ignore.push(...conf.ignore);
         }
     }
-    return [patterns.map(normalizeSep), options];
+    return [patterns.map(normalizeSep), ignore];
 }
 export async function getLoaderPath(adapter, key, localesDirAbs, root, fs) {
     const loaderPathHead = resolve(localesDirAbs, `${key}.loader`);
@@ -107,7 +105,7 @@ export class Files {
     }
     getCompiledFilePath(loc, id) {
         const ownerKey = this.#opts.ownerKey;
-        return resolve(this.#opts.localesDirAbs, generatedDir, `${ownerKey}.${id ?? ownerKey}.${loc}.compiled.js`);
+        return resolve(this.#opts.localesDirAbs, generatedDir, `${ownerKey}.${id ?? defaultLoadID}.${loc}.compiled.js`);
     }
     getImportPath(filename, importer) {
         const relTo = importer ? resolve(this.#opts.root, importer) : filename;
@@ -118,48 +116,51 @@ export class Files {
         return filename;
     }
     // typed to work regardless of user's noUncheckedIndexedAccess setting in tsconfig
-    genProxyContent(catalogs, loadIDs, syncImports) {
+    genProxyContent(catalogs, patterns, locales, syncImports) {
         const baseType = 'import("wuchale/runtime").CatalogModule';
+        const byLocale = catalogs.map((locCats, i) => `${objKeyLocale(locales[i])}: ${locCats}`).join(',');
         return `
             ${syncImports?.join('\n') ?? ''}
             /** @typedef {${syncImports ? baseType : `() => Promise<${baseType}>`}} CatalogMod */
-            /** @typedef {{[locale: string]: CatalogMod}} KeyCatalogs */
-            /** @type {{[loadID: string]: KeyCatalogs}} */
-            const catalogs = {${catalogs.join(',')}}
-            export const loadCatalog = (/** @type {string} */ loadID, /** @type {string} */ locale) => {
-                return /** @type {CatalogMod} */ (/** @type {KeyCatalogs} */ (catalogs[loadID])[locale])${syncImports ? '' : '()'}
+            /** @type {{[locale: string]: CatalogMod[]}} */
+            const catalogs = {${byLocale}}
+            export const loadCatalog = (/** @type {number} */ loadID, /** @type {string} */ locale) => {
+                return /** @type {CatalogMod} */ (/** @type {CatalogMod[]} */ (catalogs[locale])[loadID])${syncImports ? '' : '()'}
             }
-            export const loadIDs = ['${loadIDs.join("', '")}']
+            export const loadCount = ${patterns.length}
+            // not essential. in case it is needed and for debugging
+            export const patterns = ${JSON.stringify(patterns)}
         `;
     }
-    genProxy(locales, loadIDs, loadIDsImport) {
+    genProxy(locales, patterns) {
         const imports = [];
-        for (const [i, id] of loadIDs.entries()) {
-            const importsByLocale = [];
-            for (const loc of locales) {
-                importsByLocale.push(`${objKeyLocale(loc)}: () => import('${this.getImportPath(this.getCompiledFilePath(loc, loadIDsImport[i]))}')`);
+        for (const loc of locales) {
+            const importsForLocale = [];
+            for (const [loadID] of patterns.entries()) {
+                importsForLocale.push(`() => import('${this.getImportPath(this.getCompiledFilePath(loc, loadID))}')`);
             }
-            imports.push(`${id}: {${importsByLocale.join(',')}}`);
+            imports.push(`[${importsForLocale.join(',')}]`);
         }
-        return this.genProxyContent(imports, loadIDs);
+        return this.genProxyContent(imports, patterns, locales);
     }
-    genProxySync(locales, loadIDs, loadIDsImport) {
+    genProxySync(locales, patterns) {
         const imports = [];
         const object = [];
-        for (const [il, id] of loadIDs.entries()) {
-            const importedByLocale = [];
-            for (const [i, loc] of locales.entries()) {
-                const locKey = `_w_c_${id}_${i}_`;
-                imports.push(`import * as ${locKey} from '${this.getImportPath(this.getCompiledFilePath(loc, loadIDsImport[il]))}'`);
-                importedByLocale.push(`${objKeyLocale(loc)}: ${locKey}`);
+        for (const [i, loc] of locales.entries()) {
+            const importedForLocale = [];
+            for (const [loadID] of patterns.entries()) {
+                const locKey = `_w_c_${loadID}_${i}_`;
+                imports.push(`import * as ${locKey} from '${this.getImportPath(this.getCompiledFilePath(loc, loadID))}'`);
+                importedForLocale.push(locKey);
             }
-            object.push(`${id}: {${importedByLocale.join(',')}}`);
+            object.push(`[${importedForLocale.join(',')}]`);
         }
-        return this.genProxyContent(object, loadIDs, imports);
+        return this.genProxyContent(object, patterns, locales, imports);
     }
-    writeProxies = async (locales, loadIDs, loadIDsImport) => {
-        await this.#opts.fs.write(this.#proxyPath, this.genProxy(locales, loadIDs, loadIDsImport));
-        await this.#opts.fs.write(this.#proxySyncPath, this.genProxySync(locales, loadIDs, loadIDsImport));
+    writeProxies = async (locales, groupPatterns) => {
+        const allPatterns = [this.#opts.key, ...groupPatterns];
+        await this.#opts.fs.write(this.#proxyPath, this.genProxy(locales, allPatterns));
+        await this.#opts.fs.write(this.#proxySyncPath, this.genProxySync(locales, allPatterns));
     };
     static create = async (opts) => {
         const { adapter, key, localesDirAbs, root, fs } = opts;
@@ -211,7 +212,7 @@ export class Files {
     };
     getManifestFilePath(id) {
         const ownerKey = this.#opts.ownerKey;
-        return resolve(this.#opts.localesDirAbs, generatedDir, `${ownerKey}.${id ?? ownerKey}.manifest.js`);
+        return resolve(this.#opts.localesDirAbs, generatedDir, `${ownerKey}.${id ?? defaultLoadID}.manifest.js`);
     }
     writeManifest = async (keys, id) => {
         const content = `/** @type {(string | string[] | {text: string | string[], context?: string, isUrl?: boolean})[]} */\n` +
@@ -243,14 +244,6 @@ export class Files {
         }
         await this.#opts.fs.write(this.getCompiledFilePath(locale, loadID), module);
     };
-    writeTransformed = async (filename, content) => {
-        if (!this.#opts.adapter.outDir) {
-            return;
-        }
-        const fname = resolve(`${this.#opts.adapter.outDir}/${filename}`);
-        await this.#opts.fs.mkdir(dirname(fname));
-        await this.#opts.fs.write(fname, content);
-    };
     getImportLoaderPath(forServer, relativeTo) {
         return this.getImportPath(forServer ? this.#opts.loaderPath.server : this.#opts.loaderPath.client, relativeTo);
     }

package/dist/handler/index.d.ts

@@ -1,7 +1,7 @@
 import { type Matcher } from 'picomatch';
 import type { Adapter, Message, TransformOutputCode } from '../adapters.js';
 import AIQueue from '../ai/index.js';
-import type { ConfigPartial } from '../config.js';
+import type { ConfigPartial, DevMode } from '../config.js';
 import type { Logger } from '../log.js';
 import { type FileRef, type Item } from '../storage.js';
 import { Files, type FilesOptsCreatePass } from './files.js';
@@ -12,14 +12,17 @@ type TrackedRefs = Map<string, {
     ref: FileRef;
     used: number;
 }>;
-/** return two arrays: the corresponding one, and the one to import from in the case of shared catalogs */
-export declare function getLoadIDs(adapter: Adapter, key: string, ownerKey: string, granularStates: Iterable<GranularState>, sourceLocale: string): [string[], string[]];
+export declare function getLoadIDs(adapter: Adapter, granularStates: Iterable<GranularState>, sourceLocale: string): number[];
+export declare const newItemsAllowed: (mode: Mode, devMode: DevMode) => boolean;
+export declare function getFallbackChains(fallbackConf: Record<string, string>, locales: string[], sourceLocale: string): Map<string, string[]>;
 type HandlerOptsCreate = FilesOptsCreatePass & {
     config: ConfigPartial;
     mode: Mode;
     log: Logger;
     sourceLocale: string;
     sharedState: SharedState;
+    devMode: DevMode;
+    modifyInplace: boolean;
 };
 export declare class AdapterHandler {
     #private;
@@ -40,7 +43,7 @@ export declare class AdapterHandler {
     compile: (hmrVersion?: number) => Promise<void>;
     saveStorageCompile: () => Promise<void>;
     writeCompiled: (loc: string, hmrVersion?: number) => Promise<void>;
-    getCompiledFallback(index: number, loc: string): string | import("../compile.js").CompositePayload[];
+    getCompiledFallback(index: number, locale: string): string | import("../compile.js").CompositePayload[];
     popTrackedRefs: (filename: string) => TrackedRefs;
     updateRef: (item: Item, key: string, filename: string, msgInfo: Message, trackedRefrences: TrackedRefs) => boolean;
     cleanTrackedRefs: (trackedRefs: TrackedRefs) => {