wuchale 0.23.4 → 0.24.0

package/dist/handler/index.js

@@ -1,3 +1,4 @@
+import { writeFile } from 'node:fs/promises';
 import { resolve } from 'node:path';
 import { isDeepStrictEqual } from 'node:util';
 import pm, {} from 'picomatch';
@@ -6,7 +7,7 @@ import { getKey } from '../adapters.js';
 import AIQueue from '../ai/index.js';
 import { compileTranslation } from '../compile.js';
 import { itemIsUrl, newItem } from '../storage.js';
-import { Files, globConfToArgs, normalizeSep, objKeyLocale, } from './files.js';
+import { defaultLoadID, Files, globConfToArgs, normalizeSep, objKeyLocale, } from './files.js';
 import { State } from './state.js';
 import { URLHandler } from './url.js';
 const loaderImportGetRuntime = 'getRuntime';
@@ -15,19 +16,45 @@ const getFuncPlainDefault = '_w_load_';
 const urlLocalizeUdfName = 'localize';
 const getFuncReactiveDefault = `${getFuncPlainDefault}rx_`;
 const bundleCatalogsVarName = '_w_catalogs_';
-/** return two arrays: the corresponding one, and the one to import from in the case of shared catalogs */
-export function getLoadIDs(adapter, key, ownerKey, granularStates, sourceLocale) {
-    const loadIDs = [];
-    if (!adapter.granularLoad) {
-        return [[key], [ownerKey]];
+export function getLoadIDs(adapter, granularStates, sourceLocale) {
+    if (!adapter.loading.granular) {
+        return [defaultLoadID];
     }
+    const loadIDs = [];
     for (const state of granularStates) {
         // only the ones with ready messages
         if (state.compiled.get(sourceLocale).items.length) {
             loadIDs.push(state.id);
         }
     }
-    return [loadIDs, loadIDs];
+    return loadIDs;
+}
+export const newItemsAllowed = (mode, devMode) => mode !== 'dev' || devMode === 'add' || devMode === 'refs' || devMode === 'clean';
+function getFallback(fbConf, loc, sourceLocale, locales, chain) {
+    let fallback = fbConf[loc];
+    if (!fallback) {
+        if (loc.includes('-')) {
+            fallback = new Intl.Locale(loc).language;
+        }
+        if (!fallback || !locales.includes(fallback)) {
+            chain.push(sourceLocale);
+            return;
+        }
+    }
+    chain.push(fallback);
+    getFallback(fbConf, fallback, sourceLocale, locales, chain);
+}
+export function getFallbackChains(fallbackConf, locales, sourceLocale) {
+    const chains = new Map([[sourceLocale, [sourceLocale]]]);
+    for (const loc of locales) {
+        if (loc === sourceLocale) {
+            continue;
+        }
+        const chain = [loc];
+        chains.set(loc, chain);
+        getFallback(fallbackConf, loc, sourceLocale, locales, chain);
+    }
+    return chains;
 }
 export class AdapterHandler {
     key;
@@ -41,15 +68,19 @@ export class AdapterHandler {
     url;
     aiQueue;
     onBeforeSave;
+    #fallbackChains;
+    #newKeys = new Set(); // keys added during dev
     constructor(opts) {
         this.#opts = opts;
         this.key = opts.key;
         this.adapter = opts.adapter;
         this.granularState = opts.granularState;
         this.sharedState = opts.sharedState;
-        this.fileMatches = pm(...globConfToArgs(opts.adapter.files, opts.root, opts.config.localesDir, opts.adapter.outDir));
+        const [patterns, ignore] = globConfToArgs(opts.adapter.files, opts.config.localesDir);
+        this.fileMatches = pm(patterns, { ignore });
         this.sourceLocale = opts.sourceLocale;
         this.url = new URLHandler(opts.config.locales, this.sourceLocale, opts.adapter.url);
+        this.#fallbackChains = getFallbackChains(opts.config.fallback, opts.config.locales, this.sourceLocale);
         this.files = opts.files;
         if (opts.config.ai) {
             this.aiQueue = new AIQueue(opts.sourceLocale, opts.config.ai, opts.mode === 'cli' ? this.saveStorage : this.saveStorageCompile, opts.log);
@@ -65,16 +96,16 @@ export class AdapterHandler {
             fs,
             root,
         });
-        const writeProxies = states => files.writeProxies(config.locales, ...getLoadIDs(adapter, key, sharedState.ownerKey, states, opts.sourceLocale));
-        const granularState = new State(writeProxies, adapter.generateLoadID);
+        const writeProxies = groupPatts => files.writeProxies(config.locales, groupPatts);
+        const granularState = new State(writeProxies, adapter.loading.group);
         const handler = new AdapterHandler({ ...opts, granularState, files });
         await handler.loadStorage();
-        if (await handler.url.initPatterns(key, sharedState.catalog, handler.aiQueue)) {
+        if (await handler.url.initPatterns(key, sharedState.catalog, handler.#fallbackChains, handler.aiQueue)) {
             await handler.saveStorage();
         }
         await handler.compile();
-        await writeProxies(granularState.byID.values());
-        await files.writeUrlFiles(handler.url.buildManifest(sharedState.catalog), config.locales[0]);
+        await writeProxies(granularState.groupPatterns);
+        await files.writeUrlFiles(handler.url.buildManifest(), config.locales[0]);
         return handler;
     };
     loadStorage = async () => {
@@ -84,7 +115,7 @@ export class AdapterHandler {
     };
     saveStorage = async () => {
         this.onBeforeSave?.();
-        await this.sharedState.save();
+        await this.sharedState.save(this.#opts.mode === 'dev' && this.#opts.devMode === 'clean');
     };
     compile = async (hmrVersion = -1) => {
         // for proper fallback
@@ -116,10 +147,10 @@ export class AdapterHandler {
         return manifest;
     };
     #writeManifests = async () => {
-        const promises = [this.files.writeManifest(this.#buildManifest(this.sharedState.indexTracker.indices), null)];
-        if (this.adapter.granularLoad) {
+        const promises = [this.files.writeManifest(this.#buildManifest(this.sharedState.indexTracker.getAll()), null)];
+        if (this.adapter.loading.granular) {
             for (const state of this.granularState.byID.values()) {
-                promises.push(this.files.writeManifest(this.#buildManifest(state.indexTracker.indices), state.id));
+                promises.push(this.files.writeManifest(this.#buildManifest(state.indexTracker.getAll()), state.id));
             }
         }
         await Promise.all(promises);
@@ -135,7 +166,7 @@ export class AdapterHandler {
         const promises = [
             this.files.writeCatalogModule(compiledData.items, compiledData.hasPlurals ? pluralRule : null, loc, hmrVersionMode, null),
         ];
-        if (this.adapter.granularLoad) {
+        if (this.adapter.loading.granular) {
             for (const state of this.granularState.byID.values()) {
                 compiledData = state.compiled?.get(loc) || {
                     hasPlurals: false,
@@ -146,25 +177,12 @@ export class AdapterHandler {
         }
         await Promise.all(promises);
     };
-    getCompiledFallback(index, loc) {
-        for (let _ = 0; _ < 100; _++) {
-            // just to be sure
-            let fallbackLoc = this.#opts.config.fallback[loc];
-            if (fallbackLoc == null) {
-                if (loc.includes('-')) {
-                    fallbackLoc = new Intl.Locale(loc).language;
-                }
-                if (fallbackLoc == null || !this.#opts.config.locales.includes(fallbackLoc)) {
-                    fallbackLoc = this.sourceLocale;
-                }
-            }
-            const catalog = this.sharedState.compiled.get(fallbackLoc).items;
-            const compiled = catalog[index];
-            if (compiled || fallbackLoc === this.sourceLocale) {
-                // last try
+    getCompiledFallback(index, locale) {
+        for (const loc of this.#fallbackChains.get(locale) ?? [locale, this.sourceLocale]) {
+            const compiled = this.sharedState.compiled.get(loc).items[index];
+            if (compiled || loc === this.sourceLocale) {
                 return compiled || '';
             }
-            loc = fallbackLoc;
         }
         return '';
     }
@@ -207,16 +225,16 @@ export class AdapterHandler {
                 else {
                     let toCompile = transl[0];
                     if (itemIsUrl(item)) {
-                        toCompile = this.url.matchToCompile(key, this.sharedState.catalog, loc);
+                        toCompile = this.url.matchToCompile(key, loc);
                     }
                     compiled = compileTranslation(toCompile, fallback);
                 }
                 sharedCompiledLoc.items[index] = compiled;
-                if (!this.adapter.granularLoad) {
+                if (!this.adapter.loading.granular) {
                     continue;
                 }
                 for (const ref of item.references) {
-                    const state = await this.granularState.byFileCreate(ref.file, this.#opts.config.locales);
+                    const state = await this.granularState.byFileCreate(ref.file, this.#opts.config.locales, newItemsAllowed(this.#opts.mode, this.#opts.devMode));
                     const compiledLoc = state.compiled.get(loc);
                     compiledLoc.hasPlurals = sharedCompiledLoc.hasPlurals;
                     compiledLoc.items[state.indexTracker.get(key)] = compiled;
@@ -261,24 +279,20 @@ export class AdapterHandler {
             getRuntimeReactive += 'hmr_';
             head.push(this.#hmrUpdateFunc(getRuntimeVars.plain, getRuntimePlain), this.#hmrUpdateFunc(getRuntimeVars.reactive, getRuntimeReactive));
         }
-        let loaderRelTo = filename;
-        if (this.adapter.outDir) {
-            loaderRelTo = resolve(`${this.adapter.outDir}/${filename}`);
-        }
-        const loaderPath = this.files.getImportLoaderPath(forServer, loaderRelTo);
+        const loaderPath = this.files.getImportLoaderPath(forServer, filename);
         const importsFuncs = [
             `${loaderImportGetRuntime} as ${getRuntimePlain}`,
             `${loaderImportGetRuntimeRx} as ${getRuntimeReactive}`,
         ];
         head = [`import {${importsFuncs.join(', ')}} from "${loaderPath}"`, ...head];
-        if (!this.adapter.bundleLoad) {
+        if (!this.adapter.loading.direct) {
             return head.join('\n');
         }
         const imports = [];
         const objElms = [];
         for (const [i, loc] of this.#opts.config.locales.entries()) {
             const locKW = `_w_c_${i}_`;
-            const importFrom = this.files.getImportPath(this.files.getCompiledFilePath(loc, loadID), loaderRelTo);
+            const importFrom = this.files.getImportPath(this.files.getCompiledFilePath(loc, loadID), filename);
             imports.push(`import * as ${locKW} from '${importFrom}'`);
             objElms.push(`${objKeyLocale(loc)}: ${locKW}`);
         }
@@ -286,15 +300,17 @@ export class AdapterHandler {
     };
     #prepareRuntimeExpr = (loadID) => {
         const importLoaderVars = this.#getRuntimeVars();
-        if (this.adapter.bundleLoad) {
+        if (this.adapter.loading.direct) {
             return {
                 plain: `${importLoaderVars.plain}(${bundleCatalogsVarName})`,
                 reactive: `${importLoaderVars.reactive}(${bundleCatalogsVarName})`,
             };
         }
+        // default is always 0 unless loading.granular is true
+        const loadIDParam = loadID === 0 ? '' : loadID;
         return {
-            plain: `${importLoaderVars.plain}('${loadID}')`,
-            reactive: `${importLoaderVars.reactive}('${loadID}')`,
+            plain: `${importLoaderVars.plain}(${loadIDParam})`,
+            reactive: `${importLoaderVars.reactive}(${loadIDParam})`,
         };
     };
     popTrackedRefs = (filename) => {
@@ -367,6 +383,7 @@ export class AdapterHandler {
         let compileUpdated = false;
         const hmrKeys = [];
         const toTranslate = [];
+        const modifyExistingRefs = this.#opts.mode !== 'dev' || this.#opts.devMode === 'refs' || this.#opts.devMode === 'clean';
         for (const msgInfo of msgs) {
             let key = getKey(msgInfo.msgStr, msgInfo.context);
             hmrKeys.push(key);
@@ -377,16 +394,18 @@ export class AdapterHandler {
                     err.id = filename;
                     throw err;
                 }
-                key = this.url.patternKeys.get(matched); // ! because already checked at extraction
+                key = getKey([this.url.patterns[matched[0]]]);
             }
             let item = this.sharedState.catalog.get(key);
             if (!item) {
                 item = newItem({ id: msgInfo.msgStr }, this.#opts.config.locales);
                 this.sharedState.catalog.set(key, item);
+                this.#newKeys.add(key);
                 storageUpdated = true;
                 compileUpdated = true;
             }
-            if (this.updateRef(item, key, filename, msgInfo, previousReferences)) {
+            const modifyRefs = modifyExistingRefs || (this.#opts.devMode === 'add' && this.#newKeys.has(key));
+            if (modifyRefs && this.updateRef(item, key, filename, msgInfo, previousReferences)) {
                 storageUpdated = true;
                 if (msgInfo.type === 'url') {
                     compileUpdated = true;
@@ -416,16 +435,18 @@ export class AdapterHandler {
             this.aiQueue.add(toTranslate);
             await this.aiQueue.running;
         }
-        const { cleaned, cleanedUrls } = this.cleanTrackedRefs(previousReferences);
-        if (cleaned) {
-            storageUpdated = true;
-        }
-        if (cleanedUrls) {
-            compileUpdated = true;
+        if (modifyExistingRefs) {
+            const { cleaned, cleanedUrls } = this.cleanTrackedRefs(previousReferences);
+            if (cleaned) {
+                storageUpdated = true;
+            }
+            if (cleanedUrls) {
+                compileUpdated = true;
+            }
         }
+        // cli saves and compiles at the end
         if (storageUpdated && this.#opts.mode !== 'cli') {
-            // cli saves and compiles at the end
-            await this.saveStorage();
+            this.#opts.devMode && (await this.saveStorage());
             if (compileUpdated) {
                 await this.compile();
             }
@@ -435,10 +456,10 @@ export class AdapterHandler {
     transform = async (content, filename, hmrVersion = -1, forServer = false) => {
         filename = normalizeSep(filename);
         let indexTracker = this.sharedState.indexTracker;
-        let loadID = this.key;
+        let loadID = defaultLoadID;
         let compiled = this.sharedState.compiled;
-        if (this.adapter.granularLoad) {
-            const state = await this.granularState.byFileCreate(filename, this.#opts.config.locales);
+        if (this.adapter.loading.granular) {
+            const state = await this.granularState.byFileCreate(filename, this.#opts.config.locales, newItemsAllowed(this.#opts.mode, this.#opts.devMode));
             indexTracker = state.indexTracker;
             loadID = state.id;
             compiled = state.compiled;
@@ -481,7 +502,9 @@ export class AdapterHandler {
         if (msgs.length) {
             output = result.output(this.#prepareHeader(filename, loadID, hmrData, msgs.some(m => m.type === 'url'), forServer));
         }
-        await this.files.writeTransformed(filename, output.code ?? content);
+        if (this.#opts.modifyInplace && output.code) {
+            await writeFile(filename, output.code);
+        }
         return [output, updated];
     };
 }

package/dist/handler/state.d.ts

@@ -1,4 +1,4 @@
-import { IndexTracker } from '../adapters.js';
+import { IndexTracker, type LoadGroupPatt } from '../adapters.js';
 import type { CompiledElement } from '../compile.js';
 import { type Catalog, type CatalogStorage, type PluralRules } from '../storage.js';
 export type Compiled = {
@@ -15,21 +15,20 @@ export declare class SharedState {
     storage: CatalogStorage;
     catalog: Catalog;
     pluralRules: PluralRules;
-    constructor(storage: CatalogStorage, ownerKey: string, sourceLocale: string);
+    constructor(storage: CatalogStorage, ownerKey: string, sourceLocale: string, allowNewItems: boolean);
     load(locales: string[]): Promise<void>;
-    save(): Promise<void>;
+    save(onlyReferenced: boolean): Promise<void>;
 }
 export type GranularState = {
-    id: string;
+    id: number;
     compiled: CompiledCatalogs;
     indexTracker: IndexTracker;
 };
-export type WriteProxies = (states: Iterable<GranularState>) => Promise<void>;
+export type WriteProxies = (groupPatterns: LoadGroupPatt[]) => Promise<void>;
 export declare class State {
-    byFile: Map<string, GranularState>;
-    byID: Map<string, GranularState>;
-    writeProxies: WriteProxies;
-    generateLoadID: (filename: string) => string;
-    constructor(writeProxies: WriteProxies, generateLoadID: (filename: string) => string);
-    byFileCreate(filename: string, locales: string[]): Promise<GranularState>;
+    #private;
+    readonly byID: Map<number, GranularState>;
+    readonly groupPatterns: LoadGroupPatt[];
+    constructor(writeProxies: WriteProxies, groupPatterns: LoadGroupPatt[]);
+    byFileCreate(filename: string, locales: string[], allowNewItems: boolean): Promise<GranularState>;
 }

package/dist/handler/state.js

@@ -1,5 +1,6 @@
+import pm from 'picomatch';
 import { getKey, IndexTracker } from '../adapters.js';
-import { defaultPluralRule, fillTranslations } from '../storage.js';
+import { defaultPluralRule, fillTranslations, itemIsObsolete, } from '../storage.js';
 /**
  * plural rule expressions should be
  * - made of ternary and binary expressions
@@ -25,15 +26,16 @@ export class SharedState {
     ownerKey;
     sourceLocale;
     compiled = new Map();
-    indexTracker = new IndexTracker();
+    indexTracker;
     // storage
     storage;
     catalog = new Map();
     pluralRules = new Map();
-    constructor(storage, ownerKey, sourceLocale) {
+    constructor(storage, ownerKey, sourceLocale, allowNewItems) {
         this.ownerKey = ownerKey;
         this.sourceLocale = sourceLocale;
         this.storage = storage;
+        this.indexTracker = new IndexTracker(allowNewItems);
     }
     async load(locales) {
         const loaded = await this.storage.load();
@@ -54,50 +56,60 @@ export class SharedState {
             this.catalog.set(getKey(id, item.context), item);
         }
     }
-    async save() {
+    async save(onlyReferenced) {
+        const items = Array.from(this.catalog.values());
         await this.storage.save({
             pluralRules: this.pluralRules,
-            // Array important, cannot loop over map values multiple times!
-            items: Array.from(this.catalog.values()),
+            items: onlyReferenced ? items.filter(i => !itemIsObsolete(i)) : items,
         });
     }
 }
 export class State {
-    byFile = new Map();
+    #byFile = new Map();
     byID = new Map();
-    writeProxies;
-    generateLoadID;
-    constructor(writeProxies, generateLoadID) {
-        this.writeProxies = writeProxies;
-        this.generateLoadID = generateLoadID;
+    #writeProxies;
+    groupPatterns = [];
+    #groupMatches = [];
+    constructor(writeProxies, groupPatterns) {
+        this.#writeProxies = writeProxies;
+        this.groupPatterns = groupPatterns;
+        this.#groupMatches = groupPatterns.map(p => pm(p));
     }
-    async byFileCreate(filename, locales) {
-        let state = this.byFile.get(filename);
+    #getLoadID(filename) {
+        let id = -1;
+        for (const [i, match] of this.#groupMatches.entries()) {
+            if (!match(filename)) {
+                continue;
+            }
+            id = i;
+        }
+        if (id === -1) {
+            id = this.groupPatterns.length;
+            this.groupPatterns.push(filename);
+            this.#groupMatches.push(f => f === filename);
+        }
+        return id + 1; // not to start from 0 which is reserved for the shared
+    }
+    async byFileCreate(filename, locales, allowNewItems) {
+        let state = this.#byFile.get(filename);
         if (state != null) {
             return state;
         }
-        const id = this.generateLoadID(filename);
-        const stateG = this.byID.get(id);
-        if (stateG) {
-            state = stateG;
-        }
-        else {
-            const compiledLoaded = new Map();
+        const id = this.#getLoadID(filename);
+        state = this.byID.get(id);
+        if (!state) {
             state = {
                 id,
                 compiled: new Map(),
-                indexTracker: new IndexTracker(),
+                indexTracker: new IndexTracker(allowNewItems),
             };
             for (const loc of locales) {
-                state.compiled.set(loc, compiledLoaded.get(loc) ?? {
-                    hasPlurals: false,
-                    items: [],
-                });
+                state.compiled.set(loc, { hasPlurals: false, items: [] });
             }
             this.byID.set(id, state);
-            await this.writeProxies(this.byID.values());
+            await this.#writeProxies(this.groupPatterns);
         }
-        this.byFile.set(filename, state);
+        this.#byFile.set(filename, state);
         return state;
     }
 }

package/dist/handler/url.d.ts

@@ -1,18 +1,15 @@
-import { type Token } from 'path-to-regexp';
-import { type URLConf } from '../adapters.js';
+import { type URLConf, type UrlMatcher } from '../adapters.js';
 import type AIQueue from '../ai/index.js';
 import { type Catalog } from '../storage.js';
-import type { URLManifest } from '../url.js';
-export declare function patternFromTranslate(patternTranslated: string, keys: Token[]): string;
-export declare function patternToTranslate(pattern: string): string;
+import { type Pattern, type URLManifest } from '../url.js';
 export declare class URLHandler {
-    patternKeys: Map<string, string>;
-    locales: string[];
-    sourceLocale: string;
-    patterns: string[];
+    readonly locales: string[];
+    readonly sourceLocale: string;
+    readonly patterns: string[];
+    readonly compiledPatterns: Map<string, Pattern>[];
     constructor(locales: string[], sourceLocale: string, urlConf?: URLConf);
-    buildManifest: (catalog: Catalog) => URLManifest;
-    initPatterns: (adapterKey: string, catalog: Catalog, aiQueue?: AIQueue) => Promise<boolean>;
-    match: (url: string) => string | null;
-    matchToCompile: (key: string, catalog: Catalog, locale: string) => string;
+    buildManifest: () => URLManifest;
+    initPatterns: (adapterKey: string, catalog: Catalog, fallbackChains: Map<string, string[]>, aiQueue?: AIQueue) => Promise<boolean>;
+    match: UrlMatcher;
+    matchToCompile: (key: string, locale: string) => string;
 }