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
-             techniques of building the webapp. The core concept is built around widgets and
-             using .tsx to write it. Here some features:
+             This package provides you with the tools to glue your good-fellow dojo with modern
+             techniques of building the webapp. The core concept is to built around widgets and
+             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>>;
-                 default: T;
+                 private _locales: MapOf<ResolveCallback<T> | PromiseOrValue<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) {
-                     const _loc = locale || sysLocale;
-                     const locales = new Array<string>();
+                 getLocale(locale?: string) {
+                     const _loc = locale ?? sysLocale;
-                     _loc.split("-").reduce((a, x) => {
-                         a.push(x);
-                         locales.unshift(a.join("-"));
-                         return a;
-                     }, new Array<string>());
+                     // 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;
+                         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];
-                     if (isCallback(data))
-                         data = data();
+                     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/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