implab/implabjs-djx Commit - r107:e59104632d14

Working on WatchForRendition

cin -

r107:e59104632d14 default

parent child

Context file:

r107:e59104632d14

Expand all files

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

djx/src/main/ts/play.ts created 644 +16 0

@@ -0,0 +1,16
	1	import aspect = require("dojo/aspect");
	2	import { Cancellation } from "@implab/core-amd/Cancellation";
	3
	4	export const play = (ani: dojo._base.Animation, ct = Cancellation.none) => {
	5	if (ct.isSupported())
	6	ct.register(() => ani.stop());
	7
	8	return new Promise<void>(resolve => {
	9	aspect.after(ani, "onEnd", x => {
	10	resolve();
	11	return x;
	12	});
	13	ani.play();
	14	});
	15
	16	};

djx/src/main/ts/store/Observable.ts created 644 +3 0

@@ -0,0 +1,3
	1	export default class Observable<S extends dojo.store.api.Store<object>> {
	2
	3	} No newline at end of file

djx/src/main/ts/tsx/WatchForRendition.ts created 644 +215 0

@@ -0,0 +1,215
	1	import { id as mid } from "module";
	2	import { TraceSource } from "@implab/core-amd/log/TraceSource";
	3	import { argumentNotNull } from "@implab/core-amd/safe";
	4	import { getScope, render } from "./render";
	5	import { RenditionBase } from "./RenditionBase";
	6	import { Scope } from "./Scope";
	7	import { Cancellation } from "@implab/core-amd/Cancellation";
	8	import { collectNodes, destroy as safeDestroy, isDocumentFragmentNode, isElementNode, isMounted, placeAt, startupWidgets } from "./traits";
	9	import { IDestroyable } from "@implab/core-amd/interfaces";
	10	import { play } from "../play";
	11	import * as fx from "dojo/fx";
	12	import { isSubsribable, Subscribable } from "../observable";
	13	import { QueryResultUpdate } from "../tsx";
	14
	15	const trace = TraceSource.get(mid);
	16
	17	interface ItemRendition {
	18	nodes: Node[];
	19
	20	scope: IDestroyable;
	21
	22	destroy(): void;
	23	}
	24
	25	interface ObservableResults<T> {
	26	/**
	27	* Allows observation of results
	28	*/
	29	observe(listener: (object: T, previousIndex: number, newIndex: number) => void, includeUpdates?: boolean): {
	30	remove(): void;
	31	};
	32	}
	33
	34	interface RenderTask<T> extends QueryResultUpdate<T> {
	35	animate: boolean;
	36	}
	37
	38	export interface AnimationAttrs {
	39	animate?: boolean;
	40
	41	animateIn?: (nodes: Node[]) => Promise<void>;
	42
	43	animateOut?: (nodes: Node[]) => Promise<void>;
	44	}
	45
	46	export interface WatchForRenditionAttrs<T> extends AnimationAttrs {
	47	subject: T[] \| Subscribable<QueryResultUpdate<T>>;
	48
	49	component: (arg: T, index: number) => unknown;
	50	}
	51
	52	const isObservable = <T>(v: PromiseLike<ArrayLike<T>> \| ArrayLike<T>): v is ArrayLike<T> & ObservableResults<T> =>
	53	v && (typeof (v as any).observe === "function");
	54
	55	const noop = () => {};
	56
	57	const fadeIn = (nodes: Node[]) => Promise.all(nodes
	58	.filter(isElementNode)
	59	.map(el => play(fx.fadeIn({ node: el as HTMLElement })))
	60	).then(noop);
	61
	62	const fadeOut = (nodes: Node[]) => Promise.all(nodes
	63	.filter(isElementNode)
	64	.map(el => play(fx.fadeOut({ node: el as HTMLElement })))
	65	).then(noop);
	66
	67
	68	export class WatchForRendition<T> extends RenditionBase<Node> {
	69	private readonly _component: (arg: T, index: number) => unknown;
	70
	71	private readonly _node: Node;
	72
	73	private readonly _itemRenditions: ItemRendition[] = [];
	74
	75	private readonly _subject: T[] \| Subscribable<QueryResultUpdate<T>>;
	76
	77	private readonly _renderTasks: RenderTask<T>[] = [];
	78
	79	private readonly _animate: boolean;
	80
	81	private readonly _animateIn: (nodes: Node[]) => Promise<void>;
	82
	83	private readonly _animateOut: (nodes: Node[]) => Promise<void>;
	84
	85	private _ct = Cancellation.none;
	86
	87	constructor({ subject, component, animate, animateIn, animateOut }: WatchForRenditionAttrs<T>) {
	88	super();
	89	argumentNotNull(component, "component");
	90	argumentNotNull(subject, "component");
	91
	92	this._component = component;
	93
	94	this._subject = subject;
	95
	96	this._node = document.createComment("[WatchFor]");
	97	this._animate = !!animate;
	98	this._animateIn = animateIn ?? fadeIn;
	99	this._animateOut = animateOut ?? fadeOut;
	100	}
	101
	102	protected _create() {
	103	const scope = getScope();
	104	scope.own(() => {
	105	this._itemRenditions.forEach(safeDestroy);
	106	safeDestroy(this._node);
	107	});
	108
	109	const result = this._subject;
	110
	111	if (result) {
	112	if (isSubsribable<QueryResultUpdate<T>>(result)) {
	113	let animate = false;
	114	const subscription = result.subscribe({
	115	next: ({item, prevIndex, newIndex}) => this._onItemUpdated({ item, prevIndex, newIndex, animate })
	116	});
	117	scope.own(subscription);
	118	animate = this._animate;
	119	} else {
	120	if (isObservable(result))
	121	scope.own(result.observe((item, prevIndex, newIndex) => this._onItemUpdated({ item, prevIndex, newIndex, animate: false }), true));
	122
	123	for (let i = 0, n = result.length; i < n; i++)
	124	this._onItemUpdated({ item: result[i], prevIndex: -1, newIndex: i, animate: this._animate });
	125	}
	126	}
	127	this._ct = new Cancellation(cancel => scope.own(cancel));
	128	}
	129
	130	private _onItemUpdated = (item: RenderTask<T>) => {
	131	if (!this._renderTasks.length) {
	132	// schedule a new job
	133	this._renderTasks.push(item);
	134	this._render().catch(e => trace.error(e));
	135	} else {
	136	// update existing job
	137	this._renderTasks.push(item);
	138	}
	139	}
	140
	141	private async _render() {
	142	// fork
	143	await Promise.resolve();
	144	// don't render destroyed rendition
	145	if (this._ct.isRequested())
	146	return;
	147
	148	this._renderTasks.forEach(this._onRenderItem);
	149	this._renderTasks.length = 0;
	150	}
	151
	152	_onRenderItem = ({ item, newIndex, prevIndex, animate: _animate }: RenderTask<T>) => {
	153	const animate = _animate && prevIndex !== newIndex;
	154
	155	if (prevIndex > -1) {
	156	// if we need to delete previous rendition
	157	const [{ nodes, destroy }] = this._itemRenditions.splice(prevIndex, 1);
	158	if (animate) {
	159	this._animateOut(nodes)
	160	.then(destroy)
	161	.catch(e => trace.error(e));
	162	} else {
	163	destroy();
	164	}
	165	}
	166
	167	if (newIndex > -1) {
	168	// if we need to create the new rendition
	169
	170	// 1. create a new scope for rendering a content
	171	const scope = new Scope();
	172
	173	// 2. render the content
	174	const itemNode = render(this._component(item, newIndex), scope);
	175
	176	// 3. track nodes
	177	const nodes = isDocumentFragmentNode(itemNode) ?
	178	collectNodes(itemNode.childNodes) :
	179	[itemNode];
	180
	181	// 5. insert node at the correct position
	182
	183	const { nodes: [beforeNode] } = this._itemRenditions[newIndex] ?? { nodes: [] };
	184
	185	if (beforeNode)
	186	placeAt(itemNode, beforeNode, "before");
	187	else
	188	placeAt(itemNode, this._node, "before");
	189
	190	// 6. store information about rendition
	191	this._itemRenditions.splice(newIndex, 0, {
	192	scope,
	193	nodes,
	194	destroy: () => {
	195	scope.destroy();
	196	nodes.forEach(safeDestroy);
	197	}
	198	});
	199
	200	// 7. startup widgets if needed
	201	if (isMounted(this._node))
	202	nodes.forEach(n => startupWidgets(n));
	203
	204	// 8. optionally play the animation
	205	if (animate)
	206	this._animateIn(nodes).catch(e => trace.error(e));
	207	}
	208	}
	209
	210	protected _getDomNode() {
	211	if (!this._node)
	212	throw new Error("The instance of the widget isn't created");
	213	return this._node;
	214	}
	215	}

djx/src/tsconfig.eslint.json created 644 +10 0

@@ -0,0 +1,10
	1	{
	2	"extends": "./tsconfig.json",
	3	"compilerOptions": {
	4	// ensure that nobody can accidentally use this config for a build
	5	"noEmit": true
	6	},
	7	"include": [
	8	"ts"
	9	]
	10	} No newline at end of file

playground/.eslintrc.json created 644 +33 0

@@ -0,0 +1,33
	1	{
	2	"root": true,
	3	"extends": [
	4	"plugin:react/recommended",
	5	"eslint:recommended",
	6	"plugin:@typescript-eslint/eslint-recommended",
	7	"plugin:@typescript-eslint/recommended",
	8	"plugin:@typescript-eslint/recommended-requiring-type-checking"
	9	],
	10	"parser": "@typescript-eslint/parser",
	11	"parserOptions": {
	12	"ecmaFeatures": {
	13	"jsx": true
	14	},
	15	"ecmaVersion": 5,
	16	"tsconfigRootDir": "src",
	17	"project": ["tsconfig.eslint.json", "*/tsconfig.json"]
	18	},
	19	"plugins": [
	20	"@typescript-eslint"
	21	],
	22	"rules": {
	23	"@typescript-eslint/no-empty-function": "off",
	24	"max-classes-per-file": [
	25	"error",
	26	{ "ignoreExpressions": true, "max": 1 }
	27	],
	28	"@typescript-eslint/prefer-readonly": ["error"],
	29	"semi": "off",
	30	"@typescript-eslint/semi": ["error"]
	31
	32	}
	33	}

playground/src/main/ts/model/Appointment.ts created 644 0 0

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

playground/src/main/ts/model/Contact.ts created 644 0 0

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

playground/src/main/ts/model/MainContext.ts created 644 0 0

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

playground/src/main/ts/model/MainModel.ts created 644 0 0

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

playground/src/main/ts/view/MainWidget.tsx created 644 0 0

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

playground/src/main/tsconfig.json created 644 0 0

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

playground/src/tsconfig.eslint.json created 644 0 0

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

djx/.eslintrc.json +25 -17

@@ -1,25 +1,33
1	{	1	{
2	"env": {	2	"root": true,
3	"browser": true,	3	"extends": [
4	"amd": true	4	"plugin:react/recommended",
5	},	5	"eslint:recommended",
		6	"plugin:@typescript-eslint/eslint-recommended",
		7	"plugin:@typescript-eslint/recommended",
		8	"plugin:@typescript-eslint/recommended-requiring-type-checking"
		9	],
		10	"parser": "@typescript-eslint/parser",
6	"parserOptions": {	11	"parserOptions": {
7	"ecmaFeatures": {	12	"ecmaFeatures": {
8	"jsx": true	13	"jsx": true
9	},	14	},
10	"sourceType": "script"	15	"ecmaVersion": 5,
		16	"tsconfigRootDir": "djx/src",
		17	"project": ["tsconfig.eslint.json", "*/tsconfig.json"]
11	},	18	},
12	"extends": "eslint:recommended",	19	"plugins": [
		20	"@typescript-eslint"
		21	],
13	"rules": {	22	"rules": {
14	"no-const-assign": "warn",	23	"@typescript-eslint/no-empty-function": "off",
15	"no-this-before-super": "warn",	24	"max-classes-per-file": [
16	~~"no-undef"~~: "error",	25	"error",
17	"no-unreachable": "warn",	26	{ "ignoreExpressions": true, "max": 1 }
18	"no-unused-vars": "warn",	27	],
19	"constructor-super": "warn",	28	"@typescript-eslint/prefer-readonly": ["error"],
20	"~~valid-typeof~~": "~~warn~~",	29	"semi": "off",
21	"semi" : "warn",	30	"@typescript-eslint/semi": ["error"]
22	"no-invalid-this" : "error",	31
23	"no-console": "off"
24	}	32	}
25	} No newline at end of file	33	}

djx/build.gradle +1 -1

                         "dojo/*" : [ "typings/dojo/*" ],
                         "dijit/*" : [ "typings/dijit/*" ]
                     ]*/
-                    types = ["requirejs", "@implab/dojo-typings"]
+                    types = ["requirejs", "@implab/dojo-typings", "@implab/dojo-typings/dojo/NodeList-fx"]
                 }
             }

djx/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

djx/package.json +9 -3

@@ -26,10 +26,16
26	"@types/tap": "15.0.7",	26	"@types/tap": "15.0.7",
27	"dojo": "1.16.0",	27	"dojo": "1.16.0",
28	"@implab/dojo-typings": "1.0.0",	28	"@implab/dojo-typings": "1.0.0",
29	"eslint": "~~6.8~~.0",	29	"@typescript-eslint/eslint-plugin": "^5.23.0",
		30	"@typescript-eslint/parser": "^5.23.0",
		31	"eslint": "^8.23.0",
		32	"eslint-config-standard": "^17.0.0",
		33	"eslint-plugin-import": "^2.26.0",
		34	"eslint-plugin-n": "^15.2.0",
		35	"eslint-plugin-promise": "^6.0.0",
		36	"eslint-plugin-react": "^7.29.4",
30	"requirejs": "2.3.6",	37	"requirejs": "2.3.6",
31	"t~~slin~~t": "~~^6.1~~.3",	38	"typescript": "4.8.3",
32	"typescript": "4.8.2",
33	"yaml": "~1.7.2",	39	"yaml": "~1.7.2",
34	"tap": "16.3.0"	40	"tap": "16.3.0"
35	}	41	}

djx/src/main/ts/declare.ts +32 -27

             type DeclareConstructor<T> = dojo._base.DeclareConstructor<T>;
-            export interface AbstractConstructor<T = {}> {
+            export interface AbstractConstructor<T = object> {
                 prototype: T;
             }
-            interface DjMockConstructor<T = {}> {
+            interface DjMockConstructor<T = object> {
-                new(...args: any[]): T;
+                new(...args: unknown[]): T;
                 mock: boolean;
                 bases: AbstractConstructor[];
             }
+            export function djbase<T>(): DeclareConstructor<T>;
             export function djbase<T>(
-                b0?: AbstractConstructor<T>
+                b0: AbstractConstructor<T>
             ): DeclareConstructor<T>;
             export function djbase<T0, T1>(
              *  новый класс.
              *
              */
-            export function djbase(...bases: any[]): Constructor {
+            export function djbase(...bases: AbstractConstructor[]): Constructor {
                 const t = class {
                     static mock: boolean;
                 t.mock = true;
                 t.bases = bases;
-                return t as any;
+                return t as Constructor;
             }
-            function isMockConstructor<T extends {}>(v: AbstractConstructor<T>): v is DjMockConstructor<T> {
+            function isMockConstructor<T extends object>(v: AbstractConstructor<T>): v is DjMockConstructor<T> {
                 return v && "mock" in v;
             }
              */
             export function djclass<T extends AbstractConstructor>(target: T): T {
                 // получаем базовый конструктор и его прототип
-                let bp = target && target.prototype && Object.getPrototypeOf(target.prototype);
+                const bp = target && !!target.prototype && Object.getPrototypeOf(target.prototype) as object;
                 const bc = bp && bp.constructor;
                 // проверка того, что класс унаследован от специальной заглушки
                 if (isMockConstructor(bc)) {
                     // bc.bases - базовый класс, объявленный при помощи dojo/_base/declare
-                    const cls = declare<any>(bc.bases, target.prototype);
+                    const cls = declare(bc.bases, target.prototype) as unknown as T;
                     // bc - базовый класс, bc.prototype используется как super
                     // при вызове базовых методов. Нужно создать bc.prototype
                     // таким образом, чтобы он вызывал this.inherited().
-                    // создаем новый порототип, он не в цепочке прототипов у текущего
+                    // создаем новый прототип, он не в цепочке прототипов у текущего
                     // класса, но super.some_method будет использовать именно его.
                     // в этом объекте будут размещены прокси для переопределенных
                     // методов.
-                    bp = bc.prototype = Object.create(cls.prototype);
+                    const nbp = bc.prototype = Object.create(cls.prototype) as Record<string, unknown>;
-                    bp.constructor = bc;
+                    nbp.constructor = bc;
                     // proxy - фабрика для создания прокси-методов, которые внутри
                     // себя вызовут this.inherited с правильными параметрами.
-                    const proxy = (m: (...args: any[]) => any) => function (this: any) {
+                    const proxy = (m: (...args: unknown[]) => unknown) => function (this: dojo._base.DeclareCreatedObject, ...args: unknown[]) {
-                        const f = this.getInherited({ callee: m });
+                        const f = this.getInherited({ callee: m, ...args, length: args.length});
-                        return f && f.apply(this, arguments);
+                        return f ? f.apply(this, args) as unknown : undefined;
                         // так сделать можно только dojo 1.15+
                         // return this.inherited(m, arguments);
                     // создать для них прокси.
                     // При этом только те, методы, которые есть в базовых классах
                     // могут быть переопределены.
-                    each(target.prototype, (m: any, p: string | number | symbol) => {
+                    each(target.prototype, (m: unknown, p: string) => {
                         if (typeof m === "function" &&
                             p !== "constructor" &&
-                            target.prototype.hasOwnProperty(p)
+                            Object.prototype.hasOwnProperty.call(target, p)
                         ) {
-                            bp[p] = proxy(m);
+                            nbp[p] = proxy(m as (...args: unknown[]) => unknown);
                         }
                     });
                     // TODO mixin static members
-                    return cls as any;
+                    return cls;
                 } else {
-                    return target as any;
+                    return target;
                 }
             }
                 getter?: boolean;
             }
-            function isNodeBindSpec(v: any): v is NodeBindSpec {
+            function isNodeBindSpec(v: object): v is NodeBindSpec {
                 return "node" in v;
             }
              */
             export function bind(params: NodeBindSpec | MemberBindSpec) {
                 if (isNodeBindSpec(params)) {
-                    return (target: any, name: string) => {
+                    return (target: Record<string, unknown>, name: string) => {
                         target[makeSetterName(name)] = params;
                     };
                 } else {
-                    return (target: any, name: string) => {
+                    return (target: Record<string, unknown> & { _set(name: string, v: unknown): void }, name: string) => {
                         target[name] = null;
-                        target[makeSetterName(name)] = function (v: any) {
+                        target[makeSetterName(name)] = function (v: unknown) {
                             this._set(name, v);
-                            this[params.member].set(params.property, v);
+                            const inner = this[params.member] as Record<string, unknown>;
+                            if (typeof inner.set === "function")
+                                inner.set(params.property, v);
                         };
                         if (params.getter)
                             target[makeGetterName(name)] = function () {
-                                return this[params.member].get(params.property);
+                                const inner = this[params.member] as Record<string, unknown>;
+                                if (typeof inner.get === "function")
+                                    return inner.get(params.property) as unknown;
                             };
                     };
                 }
              * декоратор следует использовать для свойств, у которых нет значения по-умолчанию
              * и они не могут быть `null | undefined`
              */
-            export function prototype(): (p: any, name: string) => void;
+            export function prototype(): (p: object, name: string) => void;
             /** Создает в прототипе свойство с указанным значением.
              * @param value Значение, которое будет указано в прототипе
              */

djx/src/main/ts/observable.ts +3 -3

             export const isUnsubsribable = (v: unknown): v is Unsubscribable =>
                 v !== null && v !== undefined && typeof (v as Unsubscribable).unsubscribe === "function";
-            export const isSubsribable = (v: unknown): v is Subscribable<unknown> =>
+            export const isSubsribable = <T = unknown>(v: unknown): v is Subscribable<T> =>
                 v !== null && v !== undefined && typeof (v as Subscribable<unknown>).subscribe === "function";
             export interface Subscribable<T> {
                 filter: (predicate) => _observe(({ next, error, complete }) =>
                     producer({
                         next: next !== noop ?
-                            (v: T) => predicate(v) ? next(v) : void(0) : noop,
+                            (v: T) => predicate(v) ? next(v) : void (0) : noop,
                         error,
                         complete
                     })
                         complete
                     }))
                 ),
-                scan: (accumulator, initial?) => observe(({ next, error, complete }) => {
+                scan: (accumulator, initial) => observe(({ next, error, complete }) => {
                     let _acc = initial;
                     return producer(fuse({
                         next: next !== noop ? (v: T) => next(_acc = accumulator(_acc, v)) : noop,

djx/src/main/ts/tsx.ts +21 0

             import { Observable, observe, Subscribable } from "./observable";
             import djAttr = require("dojo/dom-attr");
             import djClass = require("dojo/dom-class");
+            import { AnimationAttrs, WatchForRendition } from "./tsx/WatchForRendition";
             export function createElement<T extends Constructor | string | ((props: any) => Element)>(elementType: T, ...args: any[]): Rendition {
                 if (typeof elementType === "string") {
                 target: HTMLElement;
             }
+            export interface QueryResultUpdate<T> {
+                /** The item is being updated */
+                item: T;
+                /** The previous index of the item, -1 in case it is inserted */
+                prevIndex: number;
+                /** The new index of the item, -1 in case it is deleted */
+                newIndex: number;
+            }
             export type DojoMouseEvent<T = any> = MouseEvent & EventSelector & EventDetails<T>;
             type StatefulProps<T> = T extends Stateful<infer A> ? A :
                 }
             }
+            export const watchFor = <T>(source: T[] | Subscribable<QueryResultUpdate<T>>, render: (item: T, index: number) => unknown, opts:  AnimationAttrs = {}) => {
+                return new WatchForRendition({
+                    ...opts,
+                    subject: source,
+                    component: render
+                });
+            }
             export const prop: {
                 <T extends Stateful, K extends string & keyof StatefulProps<T>>(target: T, name: K): Observable<StatefulProps<T>[K]>;
                 <T extends _WidgetBase, K extends keyof T>(target: T, name: K): Observable<T[K]>;

djx/src/main/ts/tsx/WatchRendition.ts +2 -2

                     this._ct = new Cancellation(cancel => scope.own(cancel));
                 }
-                private _onValue = (value: T) => {
+                private readonly _onValue = (value: T) => {
                     if (!this._renderJob) {
                         // schedule a new job
                         this._renderJob = { value };
                         // update existing job
                         this._renderJob = { value };
                     }
+                };
                 private async _render() {
                     // fork

djx/src/main/ts/tsx/traits.ts +11 -10

             import registry = require("dijit/registry");
             interface _WidgetBaseConstructor {
-                new <A = {}, E extends { [k in keyof E]: Event } = {}>(params?: Partial<_WidgetBase<E> & A>, srcNodeRef?: dojo.NodeOrString): _WidgetBase<E> & dojo._base.DeclareCreatedObject;
+                new <E extends { [k in keyof E]: Event } = {}>(params?: Partial<_WidgetBase<E>> & ThisType<_WidgetBase<E>>, srcNodeRef?: string | Node): _WidgetBase<E> & dojo._base.DeclareCreatedObject;
-                prototype: _WidgetBase<any>;
+                prototype: _WidgetBase;
             }
             export type DojoNodePosition = "first" | "after" | "before" | "last" | "replace" | "only" | number;
             export const isDocumentTypeNode = (el: unknown): el is DocumentType => isNode(el) && el.nodeType === 10;
-            export const isDocumentFragmentNode = (el: any): el is DocumentFragment => isNode(el) && el.nodeType === 11;
+            export const isDocumentFragmentNode = (el: unknown): el is DocumentFragment => isNode(el) && el.nodeType === 11;
             export const isWidget = (v: unknown): v is _WidgetBase => !!(v && "domNode" in (v as _WidgetBase));
                 if (typeof v !== "object")
                     return false;
-                const vp = Object.getPrototypeOf(v);
+                const vp = Object.getPrototypeOf(v) as object;
                 return !vp || vp === Object.prototype;
+            };
             export const isWidgetConstructor = (v: unknown): v is _WidgetBaseConstructor =>
-                typeof v === "function" && v.prototype && (
+                typeof v === "function" && !!v.prototype && (
                     "domNode" in v.prototype ||
                     "buildRendering" in v.prototype
                 );
                         parent.removeChild(target);
                 }
+            };
             /** Empties a content of the specified node and destroys all contained widgets.
              *
             export const emptyNode = (target: Node) => {
                 registry.findWidgets(target).forEach(destroy);
+                // eslint-disable-next-line no-cond-assign
                 for (let c; c = target.lastChild;) { // intentional assignment
                     target.removeChild(c);
                 }
+            };
             /** This function starts all widgets inside the DOM node if the target is a node
              * or starts widget itself if the target is the widget. If the specified node
                     if (target.startup)
                         target.startup();
                 }
+            };
             /** Places the specified DOM node at the specified location.
              *
                             break;
                     }
                 }
+            };
             /** Collects nodes from collection to an array.
              *

djx/src/main/tsconfig.json +4 -1

                         "typings"
                     ],
                     "types": [
-                        "requirejs", "./typings", "@implab/dojo-typings"
+                        "requirejs",
+                        "./typings",
+                        "@implab/dojo-typings",
+                        "@implab/dojo-typings/dojo/NodeList-fx"
                     ]
                 }
             }

djx/src/tsconfig.json 0 -1

                     "experimentalDecorators": true,
                     "jsxFactory": "createElement",
                     "target": "ES5",
-                    //"skipLibCheck": true,
                     "jsx": "react",
                     "lib": ["es5", "es2015.promise", "es2015.symbol", "es2015.iterable", "dom", "scripthost"],
                     "noUnusedLocals": true

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

playground/package.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

playground/src/main/ts/main.ts 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

playground/src/main/ts/view/ProgressBar.tsx ~~playground/src/main/ts/ProgressBar.tsx~~ renamed 0 0

NO CONTENT: file renamed from playground/src/main/ts/ProgressBar.tsx to playground/src/main/ts/view/ProgressBar.tsx

playground/src/main/ts/MainWidget.tsx removed 0 0

	1	NO CONTENT: file was removed			NO CONTENT: file was removed
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