wuchale 0.23.4 → 0.24.0

package/dist/storage.js

@@ -1,3 +1,4 @@
+import { getKey } from './adapters.js';
 export function fillTranslations(item, locales) {
     for (const loc of locales) {
         // fill empty translations
@@ -41,3 +42,100 @@ export function migrateStorage(fromStorages, toStorage) {
         };
     };
 }
+const keyAndFiles = (storages) => ({
+    key: storages.map(s => s.key).join(),
+    files: storages.flatMap(s => s.files),
+});
+export function storageByType(storages) {
+    return async (opts) => {
+        const promises = [];
+        const types = [];
+        for (const [typ, storage] of Object.entries(storages)) {
+            types.push(typ);
+            promises.push(storage(opts));
+        }
+        const all = await Promise.all(promises);
+        const byType = new Map(types.map((t, i) => [t, all[i]]));
+        return {
+            ...keyAndFiles(all),
+            load: async () => {
+                const loadeds = await Promise.all(all.map(st => st.load()));
+                return {
+                    pluralRules: loadeds.find(l => l.pluralRules)?.pluralRules,
+                    items: loadeds.flatMap(l => l.items),
+                };
+            },
+            save: async ({ items, pluralRules }) => {
+                const urls = [];
+                const msgs = [];
+                for (const item of items) {
+                    ;
+                    (itemIsUrl(item) ? urls : msgs).push(item);
+                }
+                const promises = [];
+                if (urls.length) {
+                    promises.push(byType.get('url').save({ items: urls, pluralRules }));
+                }
+                if (msgs.length) {
+                    promises.push(byType.get('message').save({ items: msgs, pluralRules }));
+                }
+                await Promise.all(promises);
+            },
+        };
+    };
+}
+export function mergeItemsByKey(allItems, sourceLocale) {
+    const items = new Map();
+    for (const allItms of allItems) {
+        for (const item of allItms) {
+            const sourceTransl = item.translations.get(sourceLocale);
+            if (!sourceTransl) {
+                throw new Error(`Source translation not found for in ${JSON.stringify(Array.from(item.translations.entries()))}`);
+            }
+            const key = getKey(sourceTransl, item.context);
+            const itemFull = items.get(key);
+            if (!itemFull) {
+                items.set(key, item);
+                continue;
+            }
+            for (const [locale, transl] of item.translations) {
+                if (transl && !itemFull.translations.get(locale)) {
+                    itemFull.translations.set(locale, transl);
+                }
+            }
+        }
+    }
+    return Array.from(items.values());
+}
+export function storageByLocale(storages) {
+    return async (opts) => {
+        const promises = [];
+        for (const [locales, storage] of storages) {
+            promises.push(storage({ ...opts, locales }));
+        }
+        const localesLeft = new Set(opts.locales);
+        const all = await Promise.all(promises);
+        for (const [locales] of storages) {
+            for (const loc of locales) {
+                localesLeft.delete(loc);
+            }
+        }
+        return {
+            ...keyAndFiles(all),
+            load: async () => {
+                let pluralRules;
+                const itemsToMerge = [];
+                for (const loaded of await Promise.all(all.map(st => st.load()))) {
+                    if (!pluralRules) {
+                        pluralRules = loaded.pluralRules;
+                    }
+                    itemsToMerge.push(loaded.items);
+                }
+                return { pluralRules, items: mergeItemsByKey(itemsToMerge, opts.sourceLocale) };
+            },
+            save: async (data) => {
+                await Promise.all(all.map(s => s.save(data)));
+            },
+        };
+    };
+}

package/dist/url.d.ts

@@ -1,17 +1,19 @@
-export type URLLocalizer = (url: string, locale: string) => string;
-export declare const localizeDefault: URLLocalizer;
-export declare const deLocalizeDefault: <L extends string>(path: string, locales: L[]) => [string, L | null];
-type MatchParams = Partial<Record<string, string | string[]>>;
-export declare const fillParams: (params: MatchParams, destPattern: string) => string;
+export type Pattern = (string | number)[];
+export declare function compilePattern(pattern: string): Pattern;
+export declare function matchPattern(pattern: Pattern, url: string): false | string[];
+export declare function stringifyPattern(pattern: Pattern, dynamics: readonly string[]): string;
 export type URLManifestItem = [
-    string,
-    string[]
-] | [string];
+    Pattern,
+    Pattern[]
+] | [Pattern];
 export type URLManifest = URLManifestItem[];
 type MatchResult<L extends string> = {
     path: string | null;
-    params: MatchParams;
-    altPatterns: Record<L, string>;
+    params: string[];
+    altPatterns: Record<L, Pattern>;
 };
 export declare function URLMatcher<L extends string>(manifest: URLManifest, locales: L[]): (url: string, locale: L | null) => MatchResult<L>;
+export type URLLocalizer = (url: string, locale: string) => string;
+export declare const localizeDefault: URLLocalizer;
+export declare const deLocalizeDefault: <L extends string>(path: string, locales: L[]) => [string, L | null];
 export {};

package/dist/url.js

@@ -1,36 +1,191 @@
-import { compile, match } from 'path-to-regexp';
-// public default, used when localized: true
-export const localizeDefault = (path, loc) => {
-    const localized = `/${loc}${path}`;
-    if (!localized.endsWith('/')) {
-        return localized;
+// $ node --import ../testing/resolve.ts %n.test.ts
+const wilds = ['/**', '/*', '*', '/?', '?']; // longer should be first
+// corresponsing indices
+const [DOUBLE, SINGLESL, SINGLE, OPTIONALSL, OPTIONAL] = [0, 1, 2, 3, 4];
+// meanings
+const [HASDOUBLE, HASSINGLE, SINGLESMIN, OPTIONALMAX, HASOPTIONAL] = [0, 1, 2, -2, -1];
+const DEFAULT_PREV_WILD = [false, -1, false, -1, false];
+export function compilePattern(pattern) {
+    const parts = [];
+    if (pattern.length > 1 && pattern.endsWith('/')) {
+        pattern = pattern.slice(0, -1);
     }
-    return localized.slice(0, -1);
-};
-export const deLocalizeDefault = (path, locales) => {
-    let iSecondSlash = path.indexOf('/', 2);
-    if (iSecondSlash === -1) {
-        iSecondSlash = path.length;
+    let prevProps = DEFAULT_PREV_WILD.slice();
+    for (let i = 0; i < pattern.length; i++) {
+        let iWildInPatMin = -1;
+        let wildIdxMin = null;
+        for (let wi = 0; wi < wilds.length; wi++) {
+            const iWildInPat = pattern.indexOf(wilds[wi], i);
+            if (iWildInPat === -1 || (iWildInPatMin !== -1 && iWildInPat >= iWildInPatMin)) {
+                continue;
+            }
+            iWildInPatMin = iWildInPat;
+            wildIdxMin = wi;
+        }
+        if (wildIdxMin === null) {
+            parts.push(pattern.slice(i));
+            prevProps = DEFAULT_PREV_WILD.slice();
+            break;
+        }
+        if (iWildInPatMin > i) {
+            const slice = pattern.slice(i, iWildInPatMin);
+            if (slice !== '/' || i === 0) {
+                parts.push(slice);
+                prevProps = DEFAULT_PREV_WILD.slice();
+            }
+        }
+        if (wildIdxMin === DOUBLE) {
+            if (!prevProps[DOUBLE]) {
+                prevProps[DOUBLE] = true;
+                parts.push(HASDOUBLE);
+            }
+        }
+        else if (wildIdxMin === OPTIONAL) {
+            if (!prevProps[OPTIONAL]) {
+                prevProps[OPTIONAL] = true;
+                parts.push(HASOPTIONAL);
+            }
+        }
+        else if (wildIdxMin === OPTIONALSL) {
+            if (prevProps[OPTIONALSL] === -1) {
+                prevProps[OPTIONALSL] = parts.length;
+                parts.push(OPTIONALMAX);
+            }
+            else {
+                ;
+                parts[prevProps[OPTIONALSL]]--;
+            }
+        }
+        else if (wildIdxMin === SINGLE) {
+            if (!prevProps[SINGLE]) {
+                prevProps[SINGLE] = true;
+                parts.push(HASSINGLE);
+            }
+        }
+        else if (wildIdxMin === SINGLESL) {
+            if (prevProps[SINGLESL] === -1) {
+                prevProps[SINGLESL] = parts.length;
+                parts.push(SINGLESMIN);
+            }
+            else {
+                ;
+                parts[prevProps[SINGLESL]]++;
+            }
+        }
+        i = iWildInPatMin + wilds[wildIdxMin].length - 1;
     }
-    const locale = path.slice(1, iSecondSlash);
-    if (!locales.includes(locale)) {
-        return [path, null];
+    return parts;
+}
+function slashCheckFails(url, fromI, toI, singles, optionals, double, single) {
+    if (fromI === toI) {
+        return singles > 0 || single;
     }
-    const rest = path.slice(1 + locale.length);
-    return [rest || '/', locale];
-};
-const getParams = (path, pattern) => {
-    const matched = match(pattern, { decode: false })(path);
-    if (!matched) {
-        return;
+    if (singles === 0 && optionals === 0) {
+        return false;
     }
-    return matched.params;
-};
-export const fillParams = (params, destPattern) => {
-    const compiled = compile(destPattern, { encode: false });
-    return compiled(params);
-};
-const noMatchRes = { path: null, altPatterns: {}, params: {} };
+    let slashes = 0;
+    for (let i = url.indexOf('/', fromI); i !== -1 && i < toI; i = url.indexOf('/', i + 1)) {
+        slashes++;
+    }
+    if (toI - fromI === slashes) {
+        return true;
+    }
+    return slashes < singles || (!double && slashes - optionals > singles);
+}
+export function matchPattern(pattern, url) {
+    let endI = url.length;
+    if (endI > 1 && url.endsWith('/')) {
+        endI--;
+    }
+    let hasDoubleLast = false;
+    let singlesLast = 0;
+    let optionalsLast = 0;
+    let hasSingleLast = false;
+    let hasOptionalLast = false;
+    let lastI = 0;
+    const dynamics = [];
+    for (const patt of pattern) {
+        if (typeof patt === 'number') {
+            if (patt === HASDOUBLE) {
+                hasDoubleLast = true;
+            }
+            else if (patt <= OPTIONALMAX) {
+                optionalsLast = OPTIONALMAX - patt + 1;
+            }
+            else if (patt === HASOPTIONAL) {
+                hasOptionalLast = true;
+            }
+            else if (patt === HASSINGLE) {
+                hasSingleLast = true;
+            }
+            else {
+                singlesLast = patt - SINGLESMIN + 1;
+            }
+            continue;
+        }
+        const singles = singlesLast;
+        const optionals = optionalsLast;
+        const hasDouble = hasDoubleLast;
+        const hasSingle = hasSingleLast;
+        const hasOptional = hasOptionalLast;
+        singlesLast = 0;
+        optionalsLast = 0;
+        hasDoubleLast = false;
+        hasOptionalLast = false;
+        hasSingleLast = false;
+        const i = url.indexOf(patt, lastI);
+        const prevI = lastI;
+        lastI = i + patt.length;
+        if (i === -1) {
+            return false;
+        }
+        if (!hasDouble && !hasOptional && !hasSingle && singles === 0 && optionals === 0) {
+            if (i > 0) {
+                return false;
+            }
+            continue;
+        }
+        if (slashCheckFails(url, prevI, i, singles, optionals, hasDouble, hasSingle)) {
+            return false;
+        }
+        dynamics.push(url.slice(prevI, i));
+    }
+    if (lastI === endI) {
+        if (singlesLast > 0 || lastI === 0) {
+            return false;
+        }
+        if (!hasDoubleLast) {
+            return dynamics;
+        }
+    }
+    if (!hasDoubleLast && !hasOptionalLast && !hasSingleLast && singlesLast === 0 && optionalsLast === 0) {
+        return false;
+    }
+    if (slashCheckFails(url, lastI, endI, singlesLast, optionalsLast, hasDoubleLast, hasSingleLast)) {
+        return false;
+    }
+    dynamics.push(url.slice(lastI, endI));
+    return dynamics;
+}
+export function stringifyPattern(pattern, dynamics) {
+    let i = 0;
+    let lastIsDynamic = false;
+    let assembled = '';
+    for (const p of pattern) {
+        if (typeof p === 'string') {
+            assembled += p;
+            lastIsDynamic = false;
+            continue;
+        }
+        if (lastIsDynamic) {
+            continue;
+        }
+        assembled += dynamics[i++] ?? ''; // undefined when optional and []
+        lastIsDynamic = true;
+    }
+    return assembled;
+}
+const noMatchRes = { path: null, altPatterns: {}, params: [] };
 export function URLMatcher(manifest, locales) {
     const manifestWithLocales = manifest.map(([pattern, localized]) => {
         localized ??= locales.map(_ => pattern);
@@ -42,11 +197,31 @@ export function URLMatcher(manifest, locales) {
             return noMatchRes;
         }
         for (const [pattern, altPatterns] of manifestWithLocales) {
-            const params = getParams(url, altPatterns[locale]);
+            const params = matchPattern(altPatterns[locale], url);
             if (params) {
-                return { path: fillParams(params, pattern), params, altPatterns };
+                return { path: stringifyPattern(pattern, params), params, altPatterns };
             }
         }
         return noMatchRes;
     };
 }
+// public default, used when localized: true
+export const localizeDefault = (path, loc) => {
+    const localized = `/${loc}${path}`;
+    if (!localized.endsWith('/')) {
+        return localized;
+    }
+    return localized.slice(0, -1);
+};
+export const deLocalizeDefault = (path, locales) => {
+    let iSecondSlash = path.indexOf('/', 2);
+    if (iSecondSlash === -1) {
+        iSecondSlash = path.length;
+    }
+    const locale = path.slice(1, iSecondSlash);
+    if (!locales.includes(locale)) {
+        return [path, null];
+    }
+    const rest = path.slice(1 + locale.length);
+    return [rest || '/', locale];
+};

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "wuchale",
-    "version": "0.23.4",
+    "version": "0.24.0",
     "description": "Protobuf-like i18n from plain code",
     "scripts": {
         "dev": "tsc --watch",
@@ -84,17 +84,16 @@
     "author": "K1DV5",
     "license": "MIT",
     "dependencies": {
-        "@sveltejs/acorn-typescript": "^1.0.9",
+        "@sveltejs/acorn-typescript": "^1.0.10",
         "acorn": "^8.16.0",
         "chokidar": "^5.0.0",
         "magic-string": "^0.30.21",
-        "path-to-regexp": "^8.4.0",
         "picomatch": "^4.0.4",
         "pofile": "^1.1.4",
-        "tinyglobby": "^0.2.16"
+        "tinyglobby": "^0.2.17"
     },
     "devDependencies": {
-        "@types/node": "~24.12.2",
+        "@types/node": "~24.13.1",
         "@types/picomatch": "^4.0.3",
         "typescript": "^6.0.3"
     },

package/src/adapter-vanilla/loaders/bundle.js

@@ -11,7 +11,7 @@ export function setLocale(newLocale) {
 }
 
 /**
- * @param {{ [locale: string]: import("wuchale/runtime").CatalogModule }} catalogs
+ * @param {{ [locale in import('${DATA}').Locale]: import("wuchale/runtime").CatalogModule }} catalogs
  */
 export const getRuntime = catalogs => toRuntime(catalogs[locale], locale)
 export const getRuntimeRx = getRuntime

package/src/adapter-vanilla/loaders/server.js

@@ -1,10 +1,10 @@
 import { loadLocales } from 'wuchale/load-utils/server'
 import { locales } from '${DATA}'
-import { loadCatalog, loadIDs } from '${PROXY_SYNC}'
+import { loadCatalog, loadCount } from '${PROXY_SYNC}'
 
-export { loadCatalog, loadIDs }
+export { loadCatalog, loadCount }
 export const key = '${KEY}'
 
 // two exports
-export const getRuntime = await loadLocales(key, loadIDs, loadCatalog, locales)
+export const getRuntime = await loadLocales(key, loadCount, loadCatalog, locales)
 export const getRuntimeRx = getRuntime

package/src/adapter-vanilla/loaders/vite.js

@@ -1,8 +1,8 @@
 import { registerLoaders } from 'wuchale/load-utils'
-import { loadCatalog, loadIDs } from '${PROXY}'
+import { loadCatalog, loadCount } from '${PROXY}'
 
 const key = '${KEY}'
 
 // two exports. can be used anywhere
-export const getRuntime = registerLoaders(key, loadCatalog, loadIDs)
+export const getRuntime = registerLoaders(key, loadCatalog, loadCount)
 export const getRuntimeRx = getRuntime

package/src/adapter-vanilla/loaders/vite.ssr.js

@@ -1,9 +1,9 @@
 import { currentRuntime } from 'wuchale/load-utils/server'
-import { loadCatalog, loadIDs } from '${PROXY_SYNC}'
+import { loadCatalog, loadCount } from '${PROXY_SYNC}'
 
 export const key = '${KEY}'
-export { loadCatalog, loadIDs } // for loading before runWithLocale
+export { loadCatalog, loadCount } // for loading before runWithLocale
 
 // two exports, same function
-export const getRuntime = (/** @type {string} */ loadID) => currentRuntime(key, loadID)
+export const getRuntime = (loadID = 0) => currentRuntime(key, loadID)
 export const getRuntimeRx = getRuntime