implab/implabjs-djx Commit - r53:deb0ed6fb680

corrected i18n, css modules to support requirejs optimizer...

cin -

r53:deb0ed6fb680 v1.0.7 default

parent child

Context file:

r53:deb0ed6fb680

Collapse all files

src/test/ts/i18n/foo.ts created 644 +8 0

@@ -0,0 +1,8
	1	import { bundle } from "../i18n";
	2
	3	export default bundle({
	4	greeting: (name: string) => `Hello, ${name}!`,
	5	goodbye: (name: string) => `Bye, ${name}!`
	6	}, {
	7	ru: () => import("./ru/foo")
	8	});

src/test/ts/i18n/ru/foo.ts created 644 +6 0

@@ -0,0 +1,6
	1	import foo from "../foo";
	2
	3	export default foo.define({
	4	greeting: (name: string) => `Привет, ${name}`,
	5	goodbye: (name: string) => `Пока, ${name}`
	6	});

src/test/ts/i18nTests.ts created 644 0 0

NO CONTENT: new file 100644

readme.md +10 -10

             ## DESCRIPTION
-            This package provides you with tools to glue your good-fellow dojo with modern
+            This package provides you with the tools to glue your good-fellow dojo with modern
-            techniques of building the webapp. The core concept is built around widgets and
+            techniques of building the webapp. The core concept is to built around widgets and
-            using .tsx to write it. Here some features:
+            using .tsx to write it. Here are some features:
             * `djbase()`, `@djaclass` - traits to declare your classes with `dojo/_base/declare`
             * `@implab/djx/tsx` - traits to build the rendering of your widgets with tsx
             * `DjxWidgetBase` - abstract class which supports tsx markup and
               `data-dojo-attach-*` attributes.
-            * `@bind(...)` - annotations provides an easy way of using standard dojo widget
+            * `@bind(...)` - annotations provide an easy way of using standard dojo widget
               attribute bindings.
             ### djbase, @djclass
-            These two traits provides convenient way of using `dojo/_base/declare` in Typescript
+            These two traits provide convenient way of using `dojo/_base/declare` in Typescript
             for declaring your classes.
             `djbase(...constructors)` - this method accepts a list of constructors in its
             parameters and returns the **fake** base type which then can be used to derive
             your own class. This allows you to provide the Typescript with the correct
-            information about the base type and even use `super`!. The only one caveat of
+            information about the base type and even use `super`!. The only caveat of
             this approach is that you **MUST** decorate your class with `@djclass` annotation.
             Consider the following example:
             <- Baz
             ```
-            Let's take a closer look to the `Baz` declaration it uses `djbase` to derive
+            Let's take a closer look at the `Baz` declaration it uses `djbase` to derive
             from three mixins and the class is decorated with `@djclass` to accomplish the
             declaration and make a real constructor.
-            To allow an access to the next sibling method (in terms of multiple inheritance)
+            To allow access to the next sibling method (in terms of multiple inheritance)
             Dojo provides `this.inherited(arguments)` method but this approach leads to the
             problem with 'strict' mode of ES5 and eliminates the type information about a
             calling method. This library solves the problem calling inherited/next method by
             the prototype of the declared class which make calls to `this.inherited(...)`
             method. This technique is compatible with 'strict' mode.
-            Mixins are declared the similar, they are also may have the base types although
+            Mixins are declared similar, they also may have the base types although
             the most common case is declaring the mixin without any base classes. To allow
-            the mixin to access the next method you should declare the interface with
+            the mixin to access the next method declare the interface with
             desired methods and use the special form of `djbase<Super>()` without arguments.
             ### DjxWidgetBase<Attrs, Events>

src/main/ts/NlsBundle.ts +23 -22

                 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;
             }
             export class NlsBundle<T extends object> {
-                _locales: MapOf<ResolveCallback<T> | PromiseOrValue<T>>;
+                private _locales: MapOf<ResolveCallback<T> | PromiseOrValue<T>>;
-                default: T;
-                _cache: MapOf<PromiseOrValue<T>>;
+                private _default: T;
+                private _cache: MapOf<PromiseOrValue<T>>;
                 constructor(defNls: T, locales?: MapOf<any>) {
-                    this.default = defNls;
+                    this._default = defNls;
                     this._locales = locales || {};
                     this._cache = {};
                 }
-                getLocale(locale: string) {
+                getLocale(locale?: string) {
-                    const _loc = locale || sysLocale;
+                    const _loc = locale ?? sysLocale;
-                    const locales = new Array<string>();
-                    _loc.split("-").reduce((a, x) => {
+                    // en-US => ["en", "en-US"]
-                        a.push(x);
+                    const locales = _loc.split(/-|_/).map((x, i, a) => a.slice(0, i + 1).join("-"));
-                        locales.unshift(a.join("-"));
-                        return a;
-                    }, new Array<string>());
                     return this._resolveLocale(locales);
                 }
                 _resolveLocale(locales: string[]): PromiseOrValue<T> {
                     if (!locales.length)
-                        return this.default;
+                        return this._default;
-                    const locale = locales.shift();
+                    const locale = locales.pop();
                     if (!locale)
-                        return this._resolveLocale(locales);
+                        throw new Error("The locale can't be empty");
                     if (this._cache[locale])
                         return this._cache[locale];
-                    let data = this._locales[locale];
+                    const data = this._loadPackage(this._locales[locale]);
-                    if (isCallback(data))
-                        data = data();
                     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/css.ts +1 -1

             const plugin = {
                 load: (id: string, require: Require, cb: OnLoad, config: { isBuild?: boolean }) => {
-                    if (config.isBuild) {
+                    if (config && config.isBuild) {
                         cb();
                     } else {
                         const url = require.toUrl(id);

src/main/ts/i18n.ts +2 -2

                 const nlsBundle = new NlsBundle(nls, locales);
                 const fn = (locale?: string) => {
-                    const result = locale ? nlsBundle.getLocale(locale) : nlsBundle.default;
+                    const result = nlsBundle.getLocale(locale);
                     if (isPromise(result))
                         throw new Error(`The bundle '${locale}' isn't loaded`);
                 };
                 fn.define = (pack: Partial<T>) => pack;
-                fn.default = nlsBundle.default;
                 fn.load = async (id: string, require: Require, cb: OnLoad, config: any) => {
                     if (config && config.isBuild) {
                         cb();
                             await nlsBundle.getLocale(id);
                             cb();
                         } catch (e) {
+                            if(cb.error)
                                 cb.error(e);
                         }
                     }

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