implab/implabjs-djx Commit - r112:2ccfaae984e9

fixed NlsBundle locale package loading...

cin -

r112:2ccfaae984e9 v1.4.4 default

parent child

Context file:

r112:2ccfaae984e9

Collapse all files

The requested changes are too big and content was truncated. Show full diff

djx/src/main/ts/NlsBundle.ts +9 -7

             import { MapOf, PromiseOrValue } from "@implab/core-amd/interfaces";
             import { argumentNotEmptyString, isPromise, mixin } from "@implab/core-amd/safe";
             export type LocaleProvider<T> = () => PromiseOrValue<T | { default: T }>;
             function when<T, T2>(value: PromiseOrValue<T>, cb: (v: T) => PromiseOrValue<T2>): PromiseOrValue<T2> {
                 return isPromise(value) ?
                     value.then(cb) :
                     cb(value);
             }
-            const chainObjects = <T extends object, T2 extends object>(o1: T, o2: T2) =>
+            const loadPackage = <T extends object>(localeData: LocaleProvider<Partial<T>> | undefined) =>
-                mixin(Object.create(o1) as T, o2);
+                localeData ?
+                    when(localeData(), data => data && "default" in data ? data.default : data) :
+                    undefined;
+            const chainObjects = <T extends object>(o1: T, o2: Partial<T> | undefined): T =>
+                o2 ? mixin(Object.create(o1) as T, o2) : o1;
             export class NlsBundle<T extends object> {
                 private readonly _locales: MapOf<LocaleProvider<Partial<T>>>;
                 private readonly _default: T;
                 private _cache: MapOf<PromiseOrValue<T>>;
                 constructor(defNls: T, locales?: MapOf<LocaleProvider<Partial<T>>>) {
                     this._default = defNls;
                     this._locales = locales || {};
                     this._cache = {};
                 }
                 getLocale(locale: string) {
                     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 data = 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: LocaleProvider<Partial<T>>) {
-                    return when(localeData(), data => data && "default" in data ? data.default : data);
             }

djx/src/main/ts/tsx/DjxFragment.ts +10 -6

@@ -1,7 +1,11
		1	import { FunctionRendition } from "./FunctionRendition";
		2	import { getItemDom } from "./render";
		3
1	/** Special functional component used to create a document fragment */	4	/** Special functional component used to create a document fragment */
2	export ~~fun~~ction DjxFragment({ children }: { children?: ~~Node~~ \| ~~Node~~[] }) {	5	export const DjxFragment = ({ children }: { children?: unknown \| unknown[] }) =>
3	const fragment = document.createDocumentFragment();	6	new FunctionRendition(() => {
4	if (children)	7	const fragment = document.createDocumentFragment();
5	(children instanceof Array ? children : [children]).forEach(child => fragment.appendChild(child));	8	if (children)
6	return fragment;	9	(children instanceof Array ? children : [children]).map(getItemDom).forEach(child => fragment.appendChild(child));
7	} No newline at end of file	10	return fragment;
		11	}); No newline at end of file

djx/src/main/ts/tsx/DjxWidgetBase.ts +9 -5

             import { djbase, djclass } from "../declare";
             import _WidgetBase = require("dijit/_WidgetBase");
             import _AttachMixin = require("dijit/_AttachMixin");
-            import { Rendition, isNode, isElementNode } from "./traits";
+            import { isNode, isElementNode } from "./traits";
             import registry = require("dijit/registry");
             import on = require("dojo/on");
             import { Scope } from "./Scope";
             import { render } from "./render";
+            import { isNull } from "@implab/core-amd/safe";
             // type Handle = dojo.Handle;
             export interface EventArgs {
                 bubbles?: boolean;
                 cancelable?: boolean;
                 composed?: boolean;
             }
             // eslint-disable-next-line @typescript-eslint/no-unused-vars
             export interface DjxWidgetBase<Attrs = object, Events extends { [name in keyof Events]: Event } = object> extends
                 _WidgetBase<Events> {
                 /** This property is declared only for type inference to work, it is never assigned
                  * and should not be used.
                  */
                 readonly _eventMap: Events & GlobalEventHandlersEventMap;
                 /** The list of pairs of event and method names. When the widget is created all methods from
                  * this list will be connected to corresponding events.
                  *
                  * This property is maintained in the prototype
                  */
                 _eventHandlers: Array<{
                     eventName: string,
                     handlerMethod: string;
                 }>;
             }
             type _super = {
                 startup(): void;
                 destroy(preserveDom?: boolean): void;
             };
             @djclass
             // eslint-disable-next-line @typescript-eslint/no-unused-vars
             export abstract class DjxWidgetBase<Attrs = object, Events = object> extends djbase<_super, _AttachMixin>(_WidgetBase, _AttachMixin) {
                 private readonly _scope = new Scope();
                 buildRendering() {
                     const node = render(this.render(), this._scope);
                     if (!isElementNode(node))
                         throw new Error("The render method must return a single DOM element");
                     this.domNode = node as HTMLElement;
                     super.buildRendering();
                     // now we should get assigned data-dojo-attach-points
                     // place the contents of the original srcNode to the containerNode
                     const src = this.srcNodeRef;
                     const dest = this.containerNode;
                     // the donNode is constructed now we need to connect event handlers
                     this._connectEventHandlers();
                     if (src && dest) {
                         while (src.firstChild)
                             dest.appendChild(src.firstChild);
                     }
                 }
-                abstract render(): Rendition;
+                abstract render(): JSX.Element;
                 private _connectEventHandlers() {
                     if (this._eventHandlers)
                         this._eventHandlers.forEach(({ eventName, handlerMethod }) => {
                             const handler = this[handlerMethod as keyof this];
                             if (typeof handler === "function")
                                 on(this.domNode, eventName, handler.bind(this) as (...args: unknown[]) => unknown);
                         });
                 }
                 _processTemplateNode<T extends (Element | Node | _WidgetBase)>(
                     baseNode: T,
-                    getAttrFunc: (baseNode: T, attr: string) => string,
+                    getAttrFunc: (baseNode: T, attr: string) => string | undefined,
                     // tslint:disable-next-line: ban-types
                     attachFunc: (node: T, type: string, func?: (...args: unknown[]) => unknown) => dojo.Handle
                 ): boolean {
                     if (isNode(baseNode)) {
                         const w = registry.byNode(baseNode);
                         if (w) {
                             // from dijit/_WidgetsInTemplateMixin
                             this._processTemplateNode(w,
-                                (n, p) => String(n.get(p as keyof typeof n)), // callback to get a property of a widget
+                                (n, p) => {
+                                    const v = n.get(p as keyof typeof n);
+                                    return isNull(v) ? undefined : String(v);
+                                }, // callback to get a property of a widget
                                 (widget, type, callback) => {
                                     if (!callback)
                                         throw new Error("The callback must be specified");
                                     // callback to do data-dojo-attach-event to a widget
                                     if (type in widget) {
                                         // back-compat, remove for 2.0
                                         return widget.connect(widget, type, callback as EventListener);
                                     } else {
                                         // 1.x may never hit this branch, but it's the default for 2.0
                                         return widget.on(type as keyof GlobalEventHandlersEventMap, callback);
                                     }
                                 });
                             // don't process widgets internals
                             return false;
                         }
                     }
                     // eslint-disable-next-line @typescript-eslint/ban-types
-                    return super._processTemplateNode(baseNode, getAttrFunc, attachFunc as (node: T, type: string, func?: Function) => dojo.Handle);
+                    return super._processTemplateNode(baseNode, getAttrFunc as (baseNode: T, attr: string) => string, attachFunc as (node: T, type: string, func?: Function) => dojo.Handle);
                 }
                 /** Starts current widget and all its supporting widgets (placed outside
                  * `containerNode`) and child widgets (placed inside `containerNode`)
                  */
                 startup() {
                     // startup supporting widgets
                     registry.findWidgets(this.domNode, this.containerNode).forEach(w => w.startup());
                     super.startup();
                 }
                 destroy(preserveDom?: boolean) {
                     this._scope.destroy();
                     super.destroy(preserveDom);
                 }
             }

djx/src/main/ts/tsx/RenditionBase.ts +1 -1

             import { isPlainObject, DojoNodePosition, Rendition, isDocumentFragmentNode, placeAt, collectNodes, isMounted, startupWidgets } from "./traits";
             export abstract class RenditionBase<TNode extends Node> implements Rendition<TNode> {
                 private _attrs = {};
                 private _children: unknown[] = [];
                 private _created = false;
                 visitNext(v: unknown) {
                     if (this._created)
                         throw new Error("The Element is already created");
                     if (v === null || v === undefined || typeof v === "boolean")
                         // skip null, undefined, booleans ( this will work:  {value && <span>{value}</span>} )
                         return;
                     if (isPlainObject(v)) {
                         this._attrs = {... this._attrs, ...v};
                     } else if (v instanceof Array) {
                         v.forEach(x => this.visitNext(x));
                     } else {
                         this._children.push(v);
                     }
                 }
                 ensureCreated() {
                     if (!this._created) {
                         this._create(this._attrs, this._children);
                         this._children = [];
                         this._attrs = {};
                         this._created = true;
                     }
                 }
                 /** Is rendition was instantiated to the DOM node */
                 isCreated() {
                     return this._created;
                 }
                 /** Creates DOM node if not created. No additional actions are taken. */
                 getDomNode() {
                     this.ensureCreated();
                     return this._getDomNode();
                 }
                 /** Creates DOM node if not created, places it to the specified position
                  * and calls startup() method for all widgets contained by this node.
                  *
                  * @param {string | Node} refNode The reference node where the created
                  *   DOM should be placed.
                  * @param {DojoNodePosition} position Optional parameter, specifies the
                  *   position relative to refNode. Default is "last" (i.e. last child).
                  */
                 placeAt(refNode: string | Node, position: DojoNodePosition = "last") {
                     const domNode = this.getDomNode();
                     const startupPending = isDocumentFragmentNode(domNode) ? collectNodes(domNode.childNodes) : [domNode];
                     placeAt(domNode, refNode, position);
-                    if (isMounted(startupPending[0]))
+                    if (startupPending.length && isMounted(startupPending[0]))
                         startupPending.forEach(n => startupWidgets(n));
                 }
                 protected abstract _create(attrs: object, children: unknown[]): void;
                 protected abstract _getDomNode(): TNode;
             }

playground/package-lock.json 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

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