implab/implabjs-djx Commit - r55:dd0d589acfbb

i18n corrected default locale selection, more verbose error reporting

cin -

r55:dd0d589acfbb v1.0.8 default

parent child

Context file:

r55:dd0d589acfbb

Collapse all files

src/main/ts/NlsBundle.ts +9 -10

-            import { MapOf } from "@implab/core-amd/interfaces";
+            import { MapOf, PromiseOrValue } from "@implab/core-amd/interfaces";
-            import { isPromise, mixin } from "@implab/core-amd/safe";
+            import { argumentNotEmptyString, isPromise, mixin } from "@implab/core-amd/safe";
-            import { locale as sysLocale } from "dojo/_base/kernel";
             import { id as mid } from "module";
             import { TraceSource } from "@implab/core-amd/log/TraceSource";
             const trace = TraceSource.get(mid);
-            type PromiseOrValue<T> = PromiseLike<T> | T;
+            export type LocaleProvider<T> = () => PromiseOrValue<T | { default: T }>;
             type ResolveCallback<T> = () => PromiseOrValue<T>;
-            trace.debug("Current sysLocale: {0}", sysLocale);
             function when<T, T2>(value: PromiseOrValue<T>, cb: (v: T) => PromiseOrValue<T2>): PromiseOrValue<T2> {
                 return isPromise(value) ?
                     value.then(cb) :
                     cb(value);
             }
             function isCallback<T>(v: ResolveCallback<T> | PromiseOrValue<T>): v is ResolveCallback<T> {
                 return typeof v === "function";
             }
             function defaultResolver(module: string) {
                 return import(module).then(x => x && x.default ? x.default : x);
             }
             function chainObjects<T extends object>(o1: T, o2: T) {
                 if (!o1)
                     return o2;
                 if (!o2)
                     return o1;
                 return mixin(Object.create(o1) as T, o2);
             }
             export class NlsBundle<T extends object> {
-                private _locales: MapOf<ResolveCallback<T> | PromiseOrValue<T>>;
+                private _locales: MapOf<LocaleProvider<Partial<T>>>;
                 private _default: T;
                 private _cache: MapOf<PromiseOrValue<T>>;
-                constructor(defNls: T, locales?: MapOf<any>) {
+                constructor(defNls: T, locales?: MapOf<LocaleProvider<Partial<T>>>) {
                     this._default = defNls;
                     this._locales = locales || {};
                     this._cache = {};
                 }
-                getLocale(locale?: string) {
+                getLocale(locale: string) {
-                    const _loc = locale ?? sysLocale;
+                    argumentNotEmptyString(locale, "locale");
+                    const _loc = locale;
                     // en-US => ["en", "en-US"]
                     const locales = _loc.split(/-|_/).map((x, i, a) => a.slice(0, i + 1).join("-"));
                     return this._resolveLocale(locales);
                 }
                 _resolveLocale(locales: string[]): PromiseOrValue<T> {
                     if (!locales.length)
                         return this._default;
                     const locale = locales.pop();
                     if (!locale)
                         throw new Error("The locale can't be empty");
                     if (this._cache[locale])
                         return this._cache[locale];
                     const data = this._loadPackage(this._locales[locale]);
                     const parent = this._resolveLocale(locales);
                     return this._cache[locale] = when(data, x => {
                         return when(parent, y => this._cache[locale] = chainObjects(y, x));
                     });
                 }
                 _loadPackage(localeData: any) {
                     if (isCallback(localeData))
                         return when(localeData(), data => data && "default" in data ? data.default : data);
                     return localeData;
                 }
             }

src/main/ts/i18n.ts +16 -3

+            import { id as mid} from "module";
             import { MapOf } from "@implab/core-amd/interfaces";
             import { NlsBundle } from "./NlsBundle";
             import { isPromise } from "@implab/core-amd/safe";
+            import { locale as sysLocale } from "dojo/_base/kernel";
+            import { TraceSource } from "@implab/core-amd/log/TraceSource";
+            const trace = TraceSource.get(mid);
+            trace.debug("Current sysLocale: {0}", sysLocale);
             export interface OnLoad {
                 (result?: any): void;
                 error(err: any): void;
             }
             export function bundle<T extends object>(nls: T, locales?: MapOf<any>) {
                 const nlsBundle = new NlsBundle(nls, locales);
-                const fn = (locale?: string) => {
+                const fn = (_locale?: string) => {
+                    const locale = _locale || sysLocale;
                     const result = nlsBundle.getLocale(locale);
                     if (isPromise(result))
                         throw new Error(`The bundle '${locale}' isn't loaded`);
                     else
                         return result;
                 };
                 fn.define = (pack: Partial<T>) => pack;
                 fn.load = async (id: string, require: Require, cb: OnLoad, config: any) => {
+                    const locale = id || sysLocale;
                     if (config && config.isBuild) {
                         cb();
                     } else {
                         try {
-                            await nlsBundle.getLocale(id);
+                            await nlsBundle.getLocale(locale);
                             cb();
                         } catch (e) {
-                            if(cb.error)
+                            if(cb.error) {
                                 cb.error(e);
+                            } else {
+                                // in case the loader doesn't support error reporting
+                                trace.error("Error loading {0}: {1}", locale, e);
+                            }
                         }
                     }
                 };
                 return fn;
             }

src/test/ts/i18n/foo.ts +1 0

             import { bundle } from "../i18n";
             export default bundle({
                 greeting: (name: string) => `Hello, ${name}!`,
                 goodbye: (name: string) => `Bye, ${name}!`
             }, {
                 ru: () => import("./ru/foo")
             });

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages