implab/implabjs-djx Commit - r120:bc1b4dd8ca1a

type fixes for i18n, store

cin -

r120:bc1b4dd8ca1a v1.6.2 default

parent child

Context file:

r120:bc1b4dd8ca1a

Collapse all files

djx/src/test/ts/nls/nls-test.ts created 644 +8 0

@@ -0,0 +1,8
	1	import { bundle } from "../i18n";
	2
	3	export const { i18n, load, define } = bundle({
	4	foo: "foo",
	5	bar: "bar"
	6	}, {
	7	ru: () => import("./ru/nls-test")
	8	}); No newline at end of file

djx/src/test/ts/nls/ru/nls-test.ts created 644 +5 0

@@ -0,0 +1,5
	1	import { define } from "../nls-test";
	2
	3	export default define({
	4	foo: "Фу"
	5	}); No newline at end of file

djx/src/main/ts/NlsBundle.ts +1 -1

             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 }>;
+            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) ?

djx/src/main/ts/i18n.ts +10 -5

             import { id as mid} from "module";
-            import { MapOf } from "@implab/core-amd/interfaces";
+            import {  PromiseOrValue } from "@implab/core-amd/interfaces";
-            import { LocaleProvider, NlsBundle } from "./NlsBundle";
+            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";
                 error(err: unknown): void;
             }
-            export function bundle<T extends object>(nls: T, locales?: MapOf<LocaleProvider<object>>) {
+            export const bundle = <T extends object>(nls: T, locales?: Record<string, () => PromiseOrValue<object>>) : {
+                i18n: (locale?: string) => T;
+                define: (pack: Partial<T>) => object;
+                load: (id: string, require: Require, cb: OnLoad, config: {isBuild?: boolean}) => void;
+            } => {
                 const nlsBundle = new NlsBundle(nls, locales);
                 const fn = (_locale?: string) => {
                         return result;
                 };
-                fn.define = (pack: Partial<T>) => pack;
+                fn.i18n = fn;
+                fn.define = (pack: Partial<T>): object => pack;
                 fn.load = async (id: string, require: Require, cb: OnLoad, config: {isBuild?: boolean}) => {
                     const locale = id || sysLocale;
                     if (config && config.isBuild) {
                 };
                 return fn;
+            };

djx/src/main/ts/store.ts +1 -1

                 v && (typeof (v as { observe?: unknown; }).observe === "function");
             export const query = <T, Q, O>(store: Queryable<T, Q, O>, includeUpdates = true) =>
-                (query?: Q, options?: O & { observe: boolean }) => {
+                (query?: Q, options?: O & { observe?: boolean }) => {
                     return observe<OrderedUpdate<T>>(({ next, complete, error, isClosed }) => {
                         try {
                             const results = store.query(query, options);

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

                 };
             };
+            /** Creates refHook to toggle the specified css class on the target element
+             *
+             * @param className
+             * @param subj a boolean observable value. When the value is false the className
+             *   is removed, when the value is true, the className is added to the target element
+             * @returns refHook
+             */
             export const toggleClass = (className: string, subj: Subscribable<boolean>) => {
                 let h = { unsubscribe() { } };
                 return (elOrWidget: HTMLElement | _WidgetBase | undefined) => {
                     const el = isWidget(elOrWidget) ? elOrWidget.domNode : elOrWidget;
                     if (el) {
                         h = subj.subscribe({
-                            next: v => djClass.toggle(el, className, v)
+                            next: v => djClass.toggle(el, className, v || false)
                         });
                     } else {
                         h.unsubscribe();
                 };
             };
+            /** Combines multiple hooks to the single one */
             export const all = <T, A extends JSX.Ref<T>[]>(...cbs: A): JSX.Ref<T> => (arg: T | undefined) => cbs.forEach(cb => cb(arg));
             /** Decorates the method which will be registered as the handle for the specified event.

djx/src/main/ts/tsx/render.ts +3 -1

                 }
             };
+            const emptyFragment = document.createDocumentFragment();
             /** Renders DOM element for different types of the argument. */
             export const getItemDom = (v: unknown) => {
                 if (typeof v === "string" || typeof v === "number" || v instanceof RegExp || v instanceof Date) {
                     return v.domNode;
                 } else if (typeof v === "boolean" || v === null || v === undefined) {
                     // null | undefined | boolean are removed
-                    return document.createDocumentFragment();
+                    return emptyFragment;
                 } else if (v instanceof Array) {
                     // arrays will be translated to document fragments
                     const fragment = document.createDocumentFragment();

djx/src/test/ts/view/MyWidget.tsx +1 -1

                 }
                 @on("count-inc")
-                private _onCounterInc(evt: Event & { detail: number; x?: number; }) {
+                protected _onCounterInc(evt: Event & { detail: number; x?: number; }) {
                     argumentNotNull(evt, "evt");
                 }

playground/package-lock.json +1 0

                     },
                     "../djx/build/npm/package": {
                         "name": "@implab/djx",
+                        "version": "1.6.2",
                         "dev": true,
                         "license": "BSD-2-Clause",
                         "peerDependencies": {

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