wuchale 0.23.3 → 0.24.0

package/dist/handler/url.js

@@ -1,34 +1,12 @@
-import { compile as compileUrlPattern, match as matchUrlPattern, pathToRegexp, stringify, } from 'path-to-regexp';
+import { isDeepStrictEqual } from 'node:util';
 import { getKey } from '../adapters.js';
-import { compileTranslation } from '../compile.js';
 import { newItem } from '../storage.js';
-export function patternFromTranslate(patternTranslated, keys) {
-    const compiledTranslatedPatt = compileTranslation(patternTranslated, patternTranslated);
-    if (typeof compiledTranslatedPatt === 'string') {
-        return compiledTranslatedPatt;
-    }
-    const urlTokens = compiledTranslatedPatt.map(part => {
-        if (typeof part === 'number') {
-            return keys[part];
-        }
-        return { type: 'text', value: part };
-    });
-    return stringify({ tokens: urlTokens });
-}
-export function patternToTranslate(pattern) {
-    const { keys } = pathToRegexp(pattern);
-    const compile = compileUrlPattern(pattern, { encode: false });
-    const paramsReplace = {};
-    for (const [i, { name }] of keys.entries()) {
-        paramsReplace[name] = `{${i}}`;
-    }
-    return compile(paramsReplace);
-}
+import { compilePattern, matchPattern, stringifyPattern } from '../url.js';
 export class URLHandler {
-    patternKeys = new Map();
     locales;
     sourceLocale;
     patterns = [];
+    compiledPatterns = [];
     constructor(locales, sourceLocale, urlConf) {
         this.locales = locales;
         this.sourceLocale = sourceLocale;
@@ -36,43 +14,33 @@ export class URLHandler {
             this.patterns = urlConf.patterns;
         }
     }
-    buildManifest = (catalog) => 
-    // order of catalogs should be based on locales
-    this.patterns.map(patt => {
-        const catalogPattKey = this.patternKeys.get(patt);
-        const { keys } = pathToRegexp(patt);
-        const locPatterns = [];
-        const item = catalog.get(catalogPattKey);
-        for (const loc of this.locales) {
-            let pattern = patt;
-            const transl = item?.translations?.get(loc);
-            if (transl) {
-                const patternTranslated = transl[0] || item.translations.get(this.sourceLocale)[0];
-                pattern = patternFromTranslate(patternTranslated, keys);
+    buildManifest = () => {
+        // order of catalogs should be based on locales
+        const manifest = [];
+        for (let i = 0; i < this.patterns.length; i++) {
+            const locPatterns = [];
+            const compiledPatts = this.compiledPatterns[i];
+            const compiledPattBase = compiledPatts.get(this.sourceLocale);
+            for (const loc of this.locales) {
+                const locCompiledPatt = compiledPatts.get(loc);
+                locPatterns.push(locCompiledPatt);
             }
-            locPatterns.push(pattern);
-        }
-        if (locPatterns.some(p => p !== patt)) {
-            return [patt, locPatterns];
+            const notAllSame = locPatterns.some(p => !isDeepStrictEqual(p, compiledPattBase));
+            manifest.push(notAllSame ? [compiledPattBase, locPatterns] : [compiledPattBase]);
         }
-        return [patt];
-    });
-    initPatterns = async (adapterKey, catalog, aiQueue) => {
-        const urlPatternsForTranslate = this.patterns.map(patternToTranslate);
+        return manifest;
+    };
+    initPatterns = async (adapterKey, catalog, fallbackChains, aiQueue) => {
         const urlPatternCatKeys = [];
         const toTranslate = [];
         let needWriteCatalog = false;
-        for (const [i, locPattern] of urlPatternsForTranslate.entries()) {
-            let context;
-            if (locPattern !== this.patterns[i]) {
-                context = `original: ${this.patterns[i]}`;
-            }
-            const key = getKey([locPattern], context);
+        const toCompile = [];
+        for (const [i, pattern] of this.patterns.entries()) {
+            const key = getKey([pattern]);
             urlPatternCatKeys[i] = key;
-            this.patternKeys.set(this.patterns[i], key); // save for href translate
             let item = catalog.get(key);
             if (!item) {
-                item = newItem({ id: [locPattern], context }, this.locales);
+                item = newItem({ id: [pattern] }, this.locales);
                 catalog.set(key, item);
                 needWriteCatalog = true;
             }
@@ -80,11 +48,12 @@ export class URLHandler {
                 item.urlAdapters.push(adapterKey);
                 needWriteCatalog = true;
             }
-            item.translations.set(this.sourceLocale, [locPattern]);
-            if (locPattern.search(/\p{L}/u) === -1) {
+            item.translations.set(this.sourceLocale, [pattern]);
+            toCompile.push(item);
+            if (pattern.search(/\p{L}/u) === -1) {
                 for (const loc of this.locales) {
                     if (loc !== this.sourceLocale) {
-                        item.translations.set(loc, [locPattern]);
+                        item.translations.set(loc, [pattern]);
                     }
                 }
                 continue;
@@ -103,41 +72,43 @@ export class URLHandler {
             aiQueue.add(toTranslate);
             await aiQueue.running;
         }
+        // for matching hrefs
+        for (const item of toCompile) {
+            const compiled = new Map();
+            for (const locale of this.locales) {
+                for (const loc of fallbackChains.get(locale) ?? [locale, this.sourceLocale]) {
+                    const pattern = item.translations.get(loc)?.[0];
+                    if (pattern) {
+                        compiled.set(locale, compilePattern(pattern));
+                        break;
+                    }
+                }
+            }
+            this.compiledPatterns.push(compiled);
+        }
         return needWriteCatalog;
     };
     match = (url) => {
-        for (const pattern of this.patterns) {
-            if (matchUrlPattern(pattern, { decode: false })(url)) {
-                return pattern;
+        for (const [i, pattern] of this.compiledPatterns.entries()) {
+            const dynamics = matchPattern(pattern.get(this.sourceLocale), url);
+            if (dynamics) {
+                return [i, dynamics];
             }
         }
         return null;
     };
-    matchToCompile = (key, catalog, locale) => {
+    matchToCompile = (key, locale) => {
         // e.g. key: /items/foo/{0}
         const toCompile = key;
         const relevantPattern = this.match(key);
         if (relevantPattern == null) {
             return toCompile;
         }
-        // e.g. relevantPattern: /items/:rest
-        const patternItem = catalog.get(this.patternKeys.get(relevantPattern));
-        if (!patternItem) {
-            return toCompile;
-        }
-        // e.g. patternItem.id: /items/{0}
-        const matchedUrl = matchUrlPattern(relevantPattern, { decode: false })(key);
-        // e.g. matchUrl.params: {rest: 'foo/{0}'}
-        if (!matchedUrl) {
-            return toCompile;
-        }
-        const translatedPattern = patternItem.translations.get(locale)[0] || patternItem.translations.get(this.sourceLocale)[0];
-        // e.g. translatedPattern: /elementos/{0}
-        const { keys } = pathToRegexp(relevantPattern);
-        const translatedPattUrl = patternFromTranslate(translatedPattern, keys);
-        // e.g. translatedPattUrl: /elementos/:rest
-        const compileTranslated = compileUrlPattern(translatedPattUrl, { encode: false });
-        return compileTranslated(matchedUrl.params);
-        // e.g. return /elementos/foo/{0}
+        // e.g. relevantPattern: [index of /items/**, [foo/{0}]]
+        const [i, dynamics] = relevantPattern;
+        const translatedCompiled = this.compiledPatterns[i].get(locale);
+        // e.g. translatedCompiled: [/elementos, 0]
+        return stringifyPattern(translatedCompiled, dynamics);
+        // e.g. /elementos/foo/{0}
     };
 }

package/dist/hub.d.ts

@@ -47,7 +47,7 @@ type TransformErrFormatter = (e: Error, adapterKey: string, filename: string) =>
 export declare class Hub {
     #private;
     private constructor();
-    static create: (mode: Mode, loadConfig: ConfigLoader, root: string, hmrDelayThreshold?: number, fs?: FS, formatTransformErr?: TransformErrFormatter) => Promise<Hub>;
+    static create: (mode: Mode, loadConfig: ConfigLoader, root: string, modifyAdapters?: string[], hmrDelayThreshold?: number, fs?: FS, formatTransformErr?: TransformErrFormatter) => Promise<Hub>;
     onFileChange: (file: string, read: () => string | Promise<string>) => Promise<FileChangeInfo | undefined>;
     transform: (code: string, filePath: string, forServer?: boolean) => ReturnType<AdapterHandler["transform"]>;
     directVisit(clean: boolean, watch: boolean, sync: boolean): Promise<void>;

package/dist/hub.js

@@ -7,7 +7,7 @@ import { glob } from 'tinyglobby';
 import { compileTranslation, isEquivalent } from './compile.js';
 import { defaultFS } from './fs.js';
 import { dataFileName, generatedDir, getLoaderPath, globConfToArgs, normalizeSep } from './handler/files.js';
-import { AdapterHandler, getLoadIDs } from './handler/index.js';
+import { AdapterHandler, getLoadIDs, newItemsAllowed } from './handler/index.js';
 import { SharedState } from './handler/state.js';
 import { color, Logger } from './log.js';
 import { itemIsObsolete, itemIsUrl } from './storage.js';
@@ -25,22 +25,21 @@ async function initGenDirWithData(config, fs, root) {
     // data file
     await fs.write(resolve(localesDirAbs, dataFileName), [
         `/** @typedef {('${config.locales.join("'|'")}')} Locale */`,
-        `/** @type {Locale[]} */`,
+        `/** @type {[Locale, ...Locale[]]} */`,
         `export const locales = ['${config.locales.join("','")}']`,
     ].join('\n'));
 }
-async function getSharedState(sharedStates, config, fs, root, adapter, key, sourceLocale) {
+async function getSharedState(sharedStates, config, fs, root, adapter, key, sourceLocale, allowNewItems) {
     const storage = await adapter.storage({
         locales: config.locales,
         root,
         localesDir: config.localesDir,
         sourceLocale: sourceLocale,
-        haveUrl: adapter.url != null,
         fs,
     });
     let sharedState = sharedStates.get(storage.key);
     if (sharedState == null) {
-        sharedState = new SharedState(storage, key, sourceLocale);
+        sharedState = new SharedState(storage, key, sourceLocale, allowNewItems);
         sharedStates.set(storage.key, sharedState);
     }
     else {
@@ -69,7 +68,7 @@ export class Hub {
                 this.#lastSourceTriggeredCatalogWrite = performance.now();
             };
             const adapter = handler.adapter;
-            if (adapter.granularLoad) {
+            if (adapter.loading.granular) {
                 this.#granularLoadHandlers.push(handler);
             }
             else {
@@ -106,7 +105,7 @@ export class Hub {
             }
         }
     }
-    static create = async (mode, loadConfig, root, hmrDelayThreshold = 1000, fs = defaultFS, formatTransformErr = e => e) => {
+    static create = async (mode, loadConfig, root, modifyAdapters = [], hmrDelayThreshold = 1000, fs = defaultFS, formatTransformErr = e => e) => {
         const config = await loadConfig();
         const adaptersData = Object.entries(config.adapters);
         if (adaptersData.length === 0) {
@@ -124,7 +123,9 @@ export class Hub {
                 adapter,
                 key,
                 sourceLocale,
-                sharedState: await getSharedState(sharedStates, config, fs, root, adapter, key, sourceLocale),
+                sharedState: await getSharedState(sharedStates, config, fs, root, adapter, key, sourceLocale, newItemsAllowed(mode, config.dev)),
+                devMode: config.dev,
+                modifyInplace: modifyAdapters.includes(key),
             });
             handlers.set(key, handler);
         }
@@ -144,12 +145,12 @@ export class Hub {
             const updateTxt = await read();
             const update = JSON.parse(updateTxt);
             this.#opts.log.info(`${logPrefix} config update received: ${color.cyan(updateTxt)}`);
-            if (update.hmr !== undefined) {
-                this.#opts.config.hmr = update.hmr;
+            if (update.dev !== undefined) {
+                this.#opts.config.dev = update.dev;
             }
             return ignoreChange;
         }
-        if (!this.#opts.config.hmr) {
+        if (!this.#opts.config.dev) {
             return;
         }
         // This is mainly to make sure that catalog file changes result in a page reload with new catalogs
@@ -183,7 +184,7 @@ export class Hub {
                 await handler.loadStorage();
                 await handler.compile(this.#hmrVersion);
             }
-            const [loadIDs] = getLoadIDs(handler.adapter, handler.key, handler.sharedState.ownerKey, handler.granularState.byID.values(), handler.sourceLocale);
+            const loadIDs = getLoadIDs(handler.adapter, handler.granularState.byID.values(), handler.sourceLocale);
             for (const loc of this.#opts.config.locales) {
                 for (const loadID of loadIDs) {
                     changeInfo.invalidate.add(normalizeSep(handler.files.getCompiledFilePath(loc, loadID)));
@@ -193,7 +194,7 @@ export class Hub {
         return changeInfo;
     };
     transform = async (code, filePath, forServer = false) => {
-        if (this.#opts.mode === 'dev' && !this.#opts.config.hmr) {
+        if (this.#opts.mode === 'dev' && !this.#opts.config.dev) {
             return [{}, false];
         }
         const filename = normalizeSep(relative(this.#opts.root, filePath));
@@ -224,7 +225,8 @@ export class Hub {
         return updated;
     };
     async #directVisitHandler(handler, clean, sync, existingFilesByOwner) {
-        const filePaths = await glob(...globConfToArgs(handler.adapter.files, this.#opts.root, this.#opts.config.localesDir, handler.adapter.outDir));
+        const [patterns, ignore] = globConfToArgs(handler.adapter.files, this.#opts.config.localesDir);
+        const filePaths = await glob(patterns, { ignore, cwd: this.#opts.root });
         let existingFiles = existingFilesByOwner.get(handler.sharedState.ownerKey);
         if (existingFiles) {
             for (const file of filePaths) {

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-export type { Adapter, AdapterArgs, AdapterPassThruOpts, CodePattern, CreateHeuristicOpts, DecideReactiveDetails, HeuristicDetails, HeuristicDetailsBase, HeuristicFunc, HeuristicResult, LoaderChoice, Message, MessageType, RuntimeConf, RuntimeExpr as CatalogExpr, TransformOutput, TransformOutputCode, URLConf, UrlMatcher, } from './adapters.js';
-export { createHeuristic, defaultGenerateLoadID, defaultHeuristic, defaultHeuristicOpts, getKey, IndexTracker, } from './adapters.js';
+export type { Adapter, AdapterArgs, AdapterPassThruOpts, CodePattern, CreateHeuristicOpts, DecideReactiveDetails, HeuristicDetails, HeuristicDetailsBase, HeuristicFunc, HeuristicResult, LoaderChoice, LoadGroupPatt, Message, MessageType, RuntimeConf, RuntimeExpr, TransformCtx, TransformOutput, TransformOutputCode, URLConf, UrlMatcher, } from './adapters.js';
+export { createHeuristic, defaultHeuristic, defaultHeuristicOpts, getKey, IndexTracker, } from './adapters.js';
 export { gemini } from './ai/gemini.js';
 export type { CompiledElement, Composite, CompositePayload, Mixed, } from './compile.js';
 export { type Config, type DeepPartial, defaultConfig, defineConfig, fillDefaults, getConfig, } from './config.js';
@@ -12,4 +12,4 @@ export { Hub } from './hub.js';
 export { Logger } from './log.js';
 export { pofile } from './pofile.js';
 export type { Catalog, CatalogStorage, FileRef, FileRefEntry, Item, LoadData, PluralRule, PluralRules, SaveData, StorageFactory, StorageFactoryOpts, } from './storage.js';
-export { defaultPluralRule, migrateStorage } from './storage.js';
+export { defaultPluralRule, mergeItemsByKey, migrateStorage, storageByLocale, storageByType } from './storage.js';

package/dist/index.js

@@ -1,4 +1,4 @@
-export { createHeuristic, defaultGenerateLoadID, defaultHeuristic, defaultHeuristicOpts, getKey, IndexTracker, } from './adapters.js';
+export { createHeuristic, defaultHeuristic, defaultHeuristicOpts, getKey, IndexTracker, } from './adapters.js';
 export { gemini } from './ai/gemini.js';
 export { defaultConfig, defineConfig, fillDefaults, getConfig, } from './config.js';
 export { generatedDir, normalizeSep } from './handler/files.js';
@@ -7,4 +7,4 @@ export { URLHandler } from './handler/url.js';
 export { Hub } from './hub.js';
 export { Logger } from './log.js';
 export { pofile } from './pofile.js';
-export { defaultPluralRule, migrateStorage } from './storage.js';
+export { defaultPluralRule, mergeItemsByKey, migrateStorage, storageByLocale, storageByType } from './storage.js';

package/dist/load-utils/index.d.ts

@@ -1,22 +1,20 @@
 import { type CatalogModule, type Runtime } from '../runtime.js';
-export type LoaderFunc = (loadID: string, locale: string) => CatalogModule | Promise<CatalogModule>;
+export type LoaderFunc = (loadID: number, locale: string) => CatalogModule | Promise<CatalogModule>;
 export type RuntimeCollection = {
-    get: (loadID: string) => Runtime;
-    set: (loadID: string, catalog: Runtime) => void;
+    get: (loadID: number) => Runtime;
+    set: (loadID: number, runtime: Runtime) => void;
 };
 export type LoaderState = {
     load: LoaderFunc;
-    catalogs: {
-        [loadID: string]: CatalogModule | undefined;
-    };
+    catalogs: (CatalogModule | undefined)[];
     collection: RuntimeCollection;
 };
-export declare function defaultCollection(store: Record<string, Runtime>): RuntimeCollection;
+export declare function defaultCollection(store: Runtime[]): RuntimeCollection;
 /**
  * - `key` is a unique identifier for the group
  * - `loadIDs` and `load` MUST be imported from the loader virtual modules or proxies.
  */
-export declare function registerLoaders(key: string, load: LoaderFunc, loadIDs: string[], collection?: RuntimeCollection): (fileID: string) => Runtime;
+export declare function registerLoaders(key: string, load: LoaderFunc, loadCount: number, collection?: RuntimeCollection): (loadID?: number) => Runtime;
 export declare function commitLocale(locale: string): void;
 /**
  * Loads catalogs using registered async loaders.

package/dist/load-utils/index.js

@@ -14,21 +14,21 @@ const emptyRuntime = toRuntime();
  * - `key` is a unique identifier for the group
  * - `loadIDs` and `load` MUST be imported from the loader virtual modules or proxies.
  */
-export function registerLoaders(key, load, loadIDs, collection) {
+export function registerLoaders(key, load, loadCount, collection) {
     states[key] = {
         load,
-        catalogs: Object.fromEntries(loadIDs.map(id => [id])),
-        collection: collection ?? defaultCollection({}),
+        catalogs: Array(loadCount).fill(undefined),
+        collection: collection ?? defaultCollection([]),
     };
-    for (const id of loadIDs) {
+    for (let id = 0; id < loadCount; id++) {
         states[key].collection.set(id, emptyRuntime);
     }
-    return loadID => states[key].collection.get(loadID);
+    return (loadID = 0) => states[key].collection.get(loadID);
 }
 /* Sets the most recently loaded locale as the current one */
 export function commitLocale(locale) {
     for (const state of Object.values(states)) {
-        for (const [loadID, catalog] of Object.entries(state.catalogs)) {
+        for (const [loadID, catalog] of state.catalogs.entries()) {
             state.collection.set(loadID, toRuntime(catalog, locale));
         }
     }
@@ -42,9 +42,9 @@ export async function loadLocale(locale, commit = true) {
     const promises = [];
     const statesArr = [];
     for (const state of Object.values(states)) {
-        for (const loadID of Object.keys(state.catalogs)) {
-            promises.push(state.load(loadID, locale));
-            statesArr.push([loadID, state]);
+        for (let id = 0; id < state.catalogs.length; id++) {
+            promises.push(state.load(id, locale));
+            statesArr.push([id, state]);
         }
     }
     for (const [i, loaded] of (await Promise.all(promises)).entries()) {
@@ -61,8 +61,8 @@ export async function loadLocale(locale, commit = true) {
  */
 export function loadLocaleSync(locale, commit = true) {
     for (const state of Object.values(states)) {
-        for (const loadID of Object.keys(state.catalogs)) {
-            state.catalogs[loadID] = state.load(loadID, locale);
+        for (let id = 0; id < state.catalogs.length; id++) {
+            state.catalogs[id] = state.load(id, locale);
         }
     }
     commit && commitLocale(locale);

package/dist/load-utils/pure.d.ts

@@ -1,5 +1,5 @@
 import type { CatalogModule } from '../runtime.js';
 import type { LoaderFunc } from './index.js';
-export type CatalogsByID = Record<string, CatalogModule>;
+export type CatalogsByID = Record<number, CatalogModule>;
 /** No-side effect way to load catalogs. Can be used for multiple file IDs. */
-export declare function loadCatalogs(locale: string, loadIDs: string[], loadCatalog: LoaderFunc): Promise<CatalogsByID>;
+export declare function loadCatalogs(locale: string, loadIDs: number[], loadCatalog: LoaderFunc): Promise<CatalogsByID>;

package/dist/load-utils/server.d.ts

@@ -1,9 +1,9 @@
 import { AsyncLocalStorage } from 'node:async_hooks';
 import { type Runtime } from '../runtime.js';
 import type { LoaderFunc } from './index.js';
-type LoadedRuntimes = Record<string, Record<string, Runtime>>;
+type LoadedRuntimes = Record<string, Runtime[]>;
 export declare const runtimeCtx: AsyncLocalStorage<LoadedRuntimes>;
-export declare function currentRuntime(key: string, loadID: string): Runtime;
-export declare function loadLocales(key: string, loadIDs: string[], load: LoaderFunc, locales: string[]): Promise<(loadID: string) => Runtime>;
+export declare function currentRuntime(key: string, loadID: number): Runtime;
+export declare function loadLocales(key: string, loadCount: number, load: LoaderFunc, locales: string[]): Promise<(loadID?: number) => Runtime>;
 export declare function runWithLocale<T>(locale: string, func: () => T): Promise<T>;
 export {};

package/dist/load-utils/server.js

@@ -19,23 +19,20 @@ export function currentRuntime(key, loadID) {
     warningShown[warnKey] = true;
     return emptyRuntime;
 }
-export async function loadLocales(key, loadIDs, load, locales) {
-    if (loadIDs == null) {
-        loadIDs = [key];
-    }
+export async function loadLocales(key, loadCount, load, locales) {
     for (const locale of locales) {
         if (!(locale in runtimes)) {
             runtimes[locale] = {};
         }
         const loaded = runtimes[locale];
         if (!(key in loaded)) {
-            loaded[key] = {};
+            loaded[key] = [];
         }
-        for (const id of loadIDs) {
+        for (let id = 0; id < loadCount; id++) {
             loaded[key][id] = toRuntime(await load(id, locale), locale);
         }
     }
-    return (loadID) => currentRuntime(key, loadID);
+    return (loadID = 0) => currentRuntime(key, loadID);
 }
 export async function runWithLocale(locale, func) {
     return await runtimeCtx.run(runtimes[locale], func);

package/dist/pofile.d.ts

@@ -2,21 +2,21 @@ import PO from 'pofile';
 import { type PluralRule, type SaveData, type StorageFactory, type StorageFactoryOpts } from './storage.js';
 export type POItem = InstanceType<typeof PO.Item>;
 export type POFileOptions = {
-    dir: string;
-    separateUrls: boolean;
+    /** in the form like 'path/to/dir/{locale}.po' */
+    location: string;
 };
 export declare const defaultOpts: POFileOptions;
 type POHeaders = Record<string, string | undefined>;
 export declare class POFile {
     key: string;
     opts: StorageFactoryOpts & POFileOptions;
-    filesByLoc: Map<string, [string, string]>;
+    filesByLoc: Map<string, string>;
     files: string[];
     fileExistsCache: Map<string, boolean>;
     constructor(opts: StorageFactoryOpts & POFileOptions);
-    loadRaw(locale: string, url: boolean): Promise<PO | null>;
+    loadRaw(locale: string): Promise<PO | null>;
     load(): Promise<SaveData>;
-    saveRaw(items: POItem[], headers: POHeaders, locale: string, url: boolean): Promise<void>;
+    saveRaw(items: POItem[], headers: POHeaders, locale: string): Promise<void>;
     save(data: SaveData): Promise<void>;
     getHeaders(locale: string, pluralRule: PluralRule): POHeaders;
 }

package/dist/pofile.js

@@ -1,8 +1,8 @@
-import { resolve } from 'node:path';
+import { dirname, resolve } from 'node:path';
 import PO from 'pofile';
 import { getKey } from './adapters.js';
 import { fillDefaults } from './config.js';
-import { itemIsObsolete, itemIsUrl, } from './storage.js';
+import { itemIsObsolete, } from './storage.js';
 const urlAdapterFlagPrefix = 'url:';
 function join(parts, sep) {
     return parts.map(s => s.replaceAll('\\', '\\\\').replaceAll(sep, `\\${sep}`)).join(sep);
@@ -79,7 +79,7 @@ function poitemToItemCommons(poi) {
         }
         for (const c of commSp.slice(phStart)) {
             const [i, ph] = split(c, ': ', 2);
-            refEnt.placeholders.push([Number(i), ph]);
+            refEnt.placeholders.push([i, ph]);
         }
         lastRef.refs.push(refEnt);
     }
@@ -124,8 +124,7 @@ function poitemsToItems(poItems, locales, sourceLocale) {
     return items;
 }
 export const defaultOpts = {
-    dir: 'src/locales',
-    separateUrls: true,
+    location: 'src/locales/{locale}.po',
 };
 export class POFile {
     key;
@@ -135,16 +134,16 @@ export class POFile {
     fileExistsCache = new Map();
     constructor(opts) {
         this.opts = opts;
-        opts.dir = resolve(opts.root, opts.dir);
-        this.key = opts.dir;
+        opts.location = resolve(opts.root, opts.location);
+        this.key = opts.location;
         for (const locale of opts.locales) {
-            const locFiles = [resolve(opts.dir, `${locale}.po`), resolve(opts.dir, `${locale}.url.po`)];
-            this.filesByLoc.set(locale, locFiles);
-            this.files.push(...locFiles);
+            const location = opts.location.replace('{locale}', locale);
+            this.filesByLoc.set(locale, location);
+            this.files.push(location);
         }
     }
-    async loadRaw(locale, url) {
-        const filename = this.filesByLoc.get(locale)[Number(url)];
+    async loadRaw(locale) {
+        const filename = this.filesByLoc.get(locale);
         const content = await this.opts.fs.read(filename);
         this.fileExistsCache.set(filename, content != null);
         return content == null ? null : PO.parse(content);
@@ -155,7 +154,7 @@ export class POFile {
         const poItems = new Map();
         // first, group by key
         for (const locale of this.opts.locales) {
-            const po = await this.loadRaw(locale, false);
+            const po = await this.loadRaw(locale);
             if (po == null) {
                 continue;
             }
@@ -165,10 +164,6 @@ export class POFile {
                 pluralRule.nplurals = Number(pluralRule.nplurals);
                 pluralRules.set(locale, pluralRule);
             }
-            if (this.opts.separateUrls && this.opts.haveUrl) {
-                const poUrl = await this.loadRaw(locale, true);
-                poUrl && po.items.push(...poUrl.items);
-            }
             for (const poItem of po.items) {
                 const key = getKey(getItemId(poItem), poItem.msgctxt);
                 if (!poItems.has(key)) {
@@ -182,8 +177,8 @@ export class POFile {
             pluralRules,
         };
     }
-    async saveRaw(items, headers, locale, url) {
-        const filename = this.filesByLoc.get(locale)[Number(url)];
+    async saveRaw(items, headers, locale) {
+        const filename = this.filesByLoc.get(locale);
         if (items.length === 0) {
             if (this.fileExistsCache.get(filename) === false) {
                 return;
@@ -199,25 +194,14 @@ export class POFile {
         this.fileExistsCache.set(filename, true);
     }
     async save(data) {
-        const useSeparateUrls = this.opts.separateUrls && this.opts.haveUrl;
-        await Promise.all(this.opts.locales.flatMap(locale => {
+        await Promise.all(this.opts.locales.map(locale => {
             const poItems = [];
-            const poItemsUrl = [];
             for (const item of data.items) {
                 const poItem = itemToPOItem(item, locale, this.opts.sourceLocale);
-                if (itemIsUrl(item) && useSeparateUrls) {
-                    poItemsUrl.push(poItem);
-                }
-                else {
-                    poItems.push(poItem);
-                }
+                poItems.push(poItem);
             }
             const headers = this.getHeaders(locale, data.pluralRules.get(locale));
-            const saveJobs = [this.saveRaw(poItems, headers, locale, false)];
-            if (useSeparateUrls) {
-                saveJobs.push(this.saveRaw(poItemsUrl, headers, locale, true));
-            }
-            return saveJobs;
+            return this.saveRaw(poItems, headers, locale);
         }));
     }
     getHeaders(locale, pluralRule) {
@@ -238,8 +222,12 @@ export class POFile {
 }
 export function pofile(pofOpts = {}) {
     return async (opts) => {
-        const fullOpts = fillDefaults(pofOpts, { ...defaultOpts, dir: opts.localesDir });
-        await opts.fs.mkdir(resolve(opts.root, fullOpts.dir)); // create once
+        const defaultLocation = resolve(opts.root, opts.localesDir, '{locale}.po');
+        const fullOpts = fillDefaults(pofOpts, { ...defaultOpts, location: defaultLocation });
+        await opts.fs.mkdir(dirname(resolve(opts.root, fullOpts.location))); // create once
+        if (!fullOpts.location.includes('{locale}')) {
+            throw new Error('PO file `location` config has to include `{locale}`');
+        }
         return new POFile({ ...opts, ...fullOpts });
     };
 }

package/dist/storage.d.ts

@@ -1,7 +1,7 @@
 import type { FS } from './fs.js';
 export type FileRefEntry = {
     link?: string | undefined;
-    placeholders: [number, string][];
+    placeholders: [string, string][];
 };
 export type FileRef = {
     file: string;
@@ -54,10 +54,13 @@ export type StorageFactoryOpts = {
     root: string;
     /** shared locale artifacts directory from the top-level config */
     localesDir: string;
-    /** whether the url is configured, can use to load separate url files */
-    haveUrl: boolean;
     sourceLocale: string;
     fs: FS;
 };
 export type StorageFactory = (opts: StorageFactoryOpts) => CatalogStorage | Promise<CatalogStorage>;
 export declare function migrateStorage(fromStorages: StorageFactory[], toStorage: StorageFactory): StorageFactory;
+type ItemType = 'message' | 'url';
+export declare function storageByType(storages: Record<ItemType, StorageFactory>): StorageFactory;
+export declare function mergeItemsByKey(allItems: Item[][], sourceLocale: string): Item[];
+export declare function storageByLocale(storages: [string[], StorageFactory][]): StorageFactory;
+export {};