implab/implabjs-djx Commit - r109:4a375b9c654a

linting

cin -

r109:4a375b9c654a default

parent child

Context file:

r109:4a375b9c654a

Expand all files

.eslintignore created 644 +1 0

	@@ -0,0 +1,1
				1	.eslintrc.js No newline at end of file

djx/.eslintrc.js created 644 +39 0

@@ -0,0 +1,39
	1	module.exports = {
	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: __dirname + "/src",
	17	project: [
	18	"tsconfig.eslint.json",
	19	"*/tsconfig.json"
	20	]
	21	},
	22	plugins: [
	23	"react",
	24	"@typescript-eslint"
	25	],
	26	rules: {
	27	"react/react-in-jsx-scope": "off",
	28	"react/no-unknown-property": "off",
	29	"@typescript-eslint/no-empty-function": "off",
	30	"max-classes-per-file": [
	31	"error",
	32	{ "ignoreExpressions": true, "max": 1 }
	33	],
	34	"@typescript-eslint/prefer-readonly": ["error"],
	35	"semi": "off",
	36	"@typescript-eslint/semi": ["error"]
	37
	38	}
	39	}

playground/.eslintrc.js created 644 +39 0

@@ -0,0 +1,39
	1	module.exports = {
	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: __dirname + "/src",
	17	project: [
	18	"tsconfig.eslint.json",
	19	"*/tsconfig.json"
	20	]
	21	},
	22	plugins: [
	23	"react",
	24	"@typescript-eslint"
	25	],
	26	rules: {
	27	"react/react-in-jsx-scope": "off",
	28	"react/no-unknown-property": "off",
	29	"@typescript-eslint/no-empty-function": "off",
	30	"max-classes-per-file": [
	31	"error",
	32	{ "ignoreExpressions": true, "max": 1 }
	33	],
	34	"@typescript-eslint/prefer-readonly": ["error"],
	35	"semi": "off",
	36	"@typescript-eslint/semi": ["error"],
	37	"react/jsx-key": "off"
	38	}
	39	}

playground/src/test/tsconfig.json created 644 +3 0

@@ -0,0 +1,3
	1	{
	2	"extends": "../tsconfig",
	3	} No newline at end of file

djx/package-lock.json +7 -7

                         "license": "BSD-2-Clause",
                         "devDependencies": {
                             "@implab/core-amd": "^1.4.0",
-                            "@implab/dojo-typings": "1.0.0",
+                            "@implab/dojo-typings": "1.0.3",
                             "@types/chai": "4.1.3",
                             "@types/requirejs": "2.1.31",
                             "@types/tap": "15.0.7",
                         "dev": true
                     },
                     "node_modules/@implab/dojo-typings": {
-                        "version": "1.0.0",
+                        "version": "1.0.3",
-                        "resolved": "https://registry.npmjs.org/@implab/dojo-typings/-/dojo-typings-1.0.0.tgz",
+                        "resolved": "https://registry.npmjs.org/@implab/dojo-typings/-/dojo-typings-1.0.3.tgz",
-                        "integrity": "sha512-B2kvlKJgvyIQAl/k1pVyNmtp4ADvBDCs4Lw/qfBC+Sz/ft4c7EuRXmN/+2dhWrd6A5SMjEgex5oeq6Ja2ntrig==",
+                        "integrity": "sha512-oyCiuU5ay9MfvdQtZNJSeV30jKufdiLBAcq6rn360pww2hzdqvWEeoU9/New8fMzyNiaEumOlgbcS11EVIH+Jg==",
                         "dev": true
                     },
                     "node_modules/@istanbuljs/load-nyc-config": {
                         "dev": true
                     },
                     "@implab/dojo-typings": {
-                        "version": "1.0.0",
+                        "version": "1.0.3",
-                        "resolved": "https://registry.npmjs.org/@implab/dojo-typings/-/dojo-typings-1.0.0.tgz",
+                        "resolved": "https://registry.npmjs.org/@implab/dojo-typings/-/dojo-typings-1.0.3.tgz",
-                        "integrity": "sha512-B2kvlKJgvyIQAl/k1pVyNmtp4ADvBDCs4Lw/qfBC+Sz/ft4c7EuRXmN/+2dhWrd6A5SMjEgex5oeq6Ja2ntrig==",
+                        "integrity": "sha512-oyCiuU5ay9MfvdQtZNJSeV30jKufdiLBAcq6rn360pww2hzdqvWEeoU9/New8fMzyNiaEumOlgbcS11EVIH+Jg==",
                         "dev": true
                     },
                     "@istanbuljs/load-nyc-config": {

djx/package.json +1 -1

                     "@types/yaml": "1.2.0",
                     "@types/tap": "15.0.7",
                     "dojo": "1.16.0",
-                    "@implab/dojo-typings": "1.0.0",
+                    "@implab/dojo-typings": "1.0.3",
                     "@typescript-eslint/eslint-plugin": "^5.23.0",
                     "@typescript-eslint/parser": "^5.23.0",
                     "eslint": "^8.23.0",

djx/src/main/ts/NlsBundle.ts +6 -21

             export type LocaleProvider<T> = () => PromiseOrValue<T | { default: T }>;
-            type ResolveCallback<T> = () => PromiseOrValue<T>;
             function when<T, T2>(value: PromiseOrValue<T>, cb: (v: T) => PromiseOrValue<T2>): PromiseOrValue<T2> {
                 return isPromise(value) ?
                     value.then(cb) :
                     cb(value);
             }
-            function isCallback<T>(v: ResolveCallback<T> | PromiseOrValue<T>): v is ResolveCallback<T> {
+            const chainObjects = <T extends object, T2 extends object>(o1: T, o2: T2) =>
-                return typeof v === "function";
+                mixin(Object.create(o1) as T, o2);
+            export class NlsBundle<T extends object> {
+                private readonly _locales: MapOf<LocaleProvider<Partial<T>>>;
-            function chainObjects<T extends object>(o1: T, o2: T) {
+                private readonly _default: T;
-                if (!o1)
-                    return o2;
-                if (!o2)
-                    return o1;
-                return mixin(Object.create(o1) as T, o2);
-            export class NlsBundle<T extends object> {
-                private _locales: MapOf<LocaleProvider<Partial<T>>>;
-                private _default: T;
                 private _cache: MapOf<PromiseOrValue<T>>;
                     });
                 }
-                _loadPackage(localeData: any) {
+                _loadPackage(localeData: LocaleProvider<Partial<T>>) {
-                    if (isCallback(localeData))
                     return when(localeData(), data => data && "default" in data ? data.default : data);
-                    return localeData;
                 }
             }

djx/src/main/ts/css.ts +2 -2

             import inject from "./dom-inject";
             interface OnLoad {
-                (result?: any): void;
+                (result?: unknown): void;
-                error(err: any): void;
+                error(err: unknown): void;
             }
             const plugin = {

djx/src/main/ts/declare.ts +14 -13

                     // proxy - фабрика для создания прокси-методов, которые внутри
                     // себя вызовут this.inherited с правильными параметрами.
-                    const proxy = (m: (...args: unknown[]) => unknown) => function (this: dojo._base.DeclareCreatedObject, ...args: unknown[]) {
+                    const proxy = (m: (...args: unknown[]) => unknown) => function (this: dojo._base.DeclareCreatedObject) {
-                        const f = this.getInherited({ callee: m, ...args, length: args.length });
+                        const f = this.getInherited({ callee: m } as unknown as IArguments);
-                        return f ? f.apply(this, args) as unknown : undefined;
+                        // eslint-disable-next-line prefer-rest-params
+                        return f ? f.apply(this, arguments) as unknown : undefined;
                         // так сделать можно только dojo 1.15+
                         // return this.inherited(m, arguments);
                     each(target.prototype, (m: unknown, p: string) => {
                         if (typeof m === "function" &&
                             p !== "constructor" &&
-                            Object.prototype.hasOwnProperty.call(target, p)
+                            Object.prototype.hasOwnProperty.call(target.prototype, p)
                         ) {
                             nbp[p] = proxy(m as (...args: unknown[]) => unknown);
                         }
                         target[makeSetterName(name) as K /** hack to not go insane) */] = params;
                     };
                 } else {
-                    return <K extends string,
+                    return <K extends string>(target: Record<K | "_set", unknown>, name: K) => {
-                        T extends { [p in K]: p extends "_set" ? (name: p, v: unknown) => void : unknown; }> (target: T, name: K) => {
+                        target[name] = undefined;
-                        target[name] = undefined as T[K];
-                        target[makeSetterName(name) as K] = function (this: T, v: unknown) {
+                        target[makeSetterName(name) as K] = function (this: typeof target, v: unknown) {
-                            this._set(name, v);
+                            (this._set as (n: K, v: unknown) => void)(name, v);
-                            const inner = this[params.member] as Record<string, unknown>;
+                            const inner = this[params.member as K] as Record<string, unknown>;
                             if (typeof inner.set === "function")
                                 inner.set(params.property, v);
-                        } as T[K];
+                        };
                         if (params.getter)
-                            target[makeGetterName(name)] = function () {
+                            target[makeGetterName(name) as K] = function (this: typeof target) {
-                                const inner = this[params.member] as Record<string, unknown>;
+                                const inner = this[params.member as K] as Record<string, unknown>;
                                 if (typeof inner.get === "function")
                                     return inner.get(params.property) as unknown;
                             };

djx/src/main/ts/dom-inject.ts +3 -3

             const trace = TraceSource.get(mid);
-            function on<T extends keyof HTMLElementEventMap>(node: HTMLElement, eventName: T, handler: (this: HTMLElement, ev: HTMLElementEventMap[T]) => any): () => void {
+            function on<T extends keyof HTMLElementEventMap>(node: HTMLElement, eventName: T, handler: (this: HTMLElement, ev: HTMLElementEventMap[T]) => unknown): () => void {
                 // Add an event listener to a DOM node
                 node.addEventListener(eventName, handler, false);
                 async injectScript(url: string) {
                     let d = this._map[url];
-                    if (!d) {
+                    if (d === undefined) {
                         trace.log("js {0}", url);
                         d = this._inject("script", {
                             type: "text/javascript",
                 async injectStylesheet(url: string) {
                     let d = this._map[url];
-                    if (!d) {
+                    if (d === undefined) {
                         trace.log("js {0}", url);
                         d = this._inject("link", {
                             type: "text/css",

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

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

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

                     next: next ? next.bind(consumer) : noop,
                     error: error ? error.bind(consumer) : noop,
                     complete: complete ? complete.bind(consumer) : noop
+                };
             };
             const fuse = <T>({ next, error, complete }: Sink<T>) => {
                 let done = false;
                 return {
-                    next: (value: T) => { !done && next(value) },
+                    next: (value: T) => { !done && next(value); },
-                    error: (e: unknown) => { !done && (done = true, error(e)) },
+                    error: (e: unknown) => { !done && (done = true, error(e)); },
-                    complete: () => { !done && (done = true, complete()) }
+                    complete: () => { !done && (done = true, complete()); }
+                };
+            };
             const _observe = <T>(producer: Producer<T>): Observable<T> => ({
                 subscribe: (consumer: Partial<Observer<T>>) => ({

djx/src/main/ts/tsx.ts +17 -16

             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 {
+            export function createElement<T extends Constructor | string | ((props: object) => Element)>(elementType: T, ...args: unknown[]): Rendition {
                 if (typeof elementType === "string") {
                     const ctx = new HtmlRendition(elementType);
                     if (args)
                     return ctx;
                 } else if (typeof elementType === "function") {
-                    const ctx = new FunctionRendition(elementType as (props: any) => Element);
+                    const ctx = new FunctionRendition(elementType as (props: unknown) => Element);
                     if (args)
                         args.forEach(x => ctx.visitNext(x));
                     return ctx;
                 } else {
-                    throw new Error(`The element type '${elementType}' is unsupported`);
+                    throw new Error(`The element type '${String(elementType)}' is unsupported`);
                 }
             }
-            export interface EventDetails<T = any> {
+            export interface EventDetails<T = unknown> {
                 detail: T;
             }
                 newIndex: number;
             }
-            export type DojoMouseEvent<T = any> = MouseEvent & EventSelector & EventDetails<T>;
+            export type DojoMouseEvent<T = unknown> = MouseEvent & EventSelector & EventDetails<T>;
             type StatefulProps<T> = T extends Stateful<infer A> ? A :
                 T extends _WidgetBase ? T : never;
             export function watch<W extends _WidgetBase, K extends keyof W>(
                 target: W,
                 prop: K,
-                render: (model: W[K]) => any
+                render: (model: W[K]) => unknown
             ): Rendition;
             /**
              * Observers the property and calls render callback each change.
             export function watch<T extends Stateful, K extends keyof StatefulProps<T>>(
                 target: T,
                 prop: K,
-                render: (model: StatefulProps<T>[K]) => any
+                render: (model: StatefulProps<T>[K]) => unknown
             ): Rendition;
             export function watch<V>(subj: Subscribable<V>, render: (model: V) => unknown): Rendition;
             export function watch(
                     return new WatchRendition(
                         render,
                         observe(({next}) => {
-                            const h = target.watch<any>(
+                            const h = target.watch(
                                 prop,
                                 (_prop, oldValue, newValue) => oldValue !== newValue && next(newValue)
                             );
                     subject: source,
                     component: render
                 });
+            };
             export const prop: {
                     );
                     next(target.get(name));
                     return () => h.remove();
-                })
+                });
             };
             export const attach = <W extends DjxWidgetBase, K extends keyof W>(target: W, name: K) => (v: W[K]) => target.set(name, v);
             export const bind = <K extends string, T>(attr: K, subj: Subscribable<T>) => {
                 let h = { unsubscribe() { } };
-                return <E extends (HTMLElement & { [p in K]: T }) | { set(name: K, value: T): void; }>(el: E | undefined) => {
+                return (el: Element | { set(name: K, value: T): void; } | undefined) => {
                     if (el) {
                         if (isElementNode(el)) {
                             h = subj.subscribe({
                     } else {
                         h.unsubscribe();
                     }
+                };
             };
             export const toggleClass = (className: string, subj: Subscribable<boolean>) => {
                     } else {
                         h.unsubscribe();
                     }
+                };
+            };
             export const all = <T, A extends JSX.Ref<T>[]>(...cbs: A): JSX.Ref<T> => (arg: T | undefined) => cbs.forEach(cb => cb(arg));
              */
             export const on = <E extends string>(...eventNames: E[]) =>
                 <K extends string,
-                    T extends DjxWidgetBase<any, { [p in E]: EV }>,
+                    T extends DjxWidgetBase<object, { [p in E]: EV }>,
                     EV extends Event
                 >(
                     target: T,
                     key: K,
+                    // eslint-disable-next-line @typescript-eslint/no-unused-vars
                     _descriptor: TypedPropertyDescriptor<(eventObj: EV) => void> | TypedPropertyDescriptor<() => void>
-                ): any => {
+                ) => {
                     const handlers = eventNames.map(eventName => ({ eventName, handlerMethod: key }));
                     target._eventHandlers = target._eventHandlers ? target._eventHandlers.concat(handlers) : handlers;
                 };

djx/src/main/ts/tsx/DjxWidgetBase.ts +13 -10

                 composed?: boolean;
             }
-            export interface DjxWidgetBase<Attrs = {}, Events extends { [name in keyof Events]: Event } = {}> extends
+            // 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
                  */
                 _eventHandlers: Array<{
                     eventName: string,
-                    handlerMethod: keyof any;
+                    handlerMethod: string;
                 }>;
             }
             };
             @djclass
-            export abstract class DjxWidgetBase<Attrs = {}, Events = {}> extends djbase<_super, _AttachMixin>(_WidgetBase, _AttachMixin) {
+            // 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() {
                     }
                 }
-                abstract render(): Rendition<HTMLElement>;
+                abstract render(): Rendition;
                 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));
+                                on(this.domNode, eventName, handler.bind(this) as (...args: unknown[]) => unknown);
                         });
                 }
                 _processTemplateNode<T extends (Element | Node | _WidgetBase)>(
                     baseNode: T,
-                    getAttrFunc: (baseNode: T, attr: string) => any,
+                    getAttrFunc: (baseNode: T, attr: string) => string,
                     // tslint:disable-next-line: ban-types
-                    attachFunc: (node: T, type: string, func?: Function) => dojo.Handle
+                    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) => n.get(p as any), // callback to get a property of a widget
+                                (n, p) => String(n.get(p as keyof typeof n)), // callback to get a property of a widget
                                 (widget, type, callback) => {
                                     if (!callback)
                                         throw new Error("The callback must be specified");
                                         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, callback);
+                                        return widget.on(type as keyof GlobalEventHandlersEventMap, callback);
                                     }
                                 });
                             return false;
                         }
                     }
-                    return super._processTemplateNode(baseNode, getAttrFunc, attachFunc);
+                    // eslint-disable-next-line @typescript-eslint/ban-types
+                    return super._processTemplateNode(baseNode, getAttrFunc, attachFunc as (node: T, type: string, func?: Function) => dojo.Handle);
                 }
                 /** Starts current widget and all its supporting widgets (placed outside

djx/src/main/ts/tsx/FunctionRendition.ts +4 -4

             import { RenditionBase } from "./RenditionBase";
             export class FunctionRendition extends RenditionBase<Node> {
-                private _component: (...args: any[]) => any;
+                private readonly _component: (...args: unknown[]) => unknown;
                 private _node: Node | undefined;
-                constructor(component: (...args: any[]) => any) {
+                constructor(component: (...args: unknown[]) => unknown) {
                     super();
                     argumentNotNull(component, "component");
                     this._component = component;
                 }
-                protected _create(attrs: object, children: any[]) {
+                protected _create(attrs: object, children: unknown[]) {
-                    const _attrs: any = attrs || {};
+                    const _attrs = attrs || {};
                     const _children = children.map(x => getItemDom(x));
                     this._node = getItemDom(
                         this._component.call(null, { ..._attrs, children: _children }));

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

             export abstract class RenditionBase<TNode extends Node> implements Rendition<TNode> {
                 private _attrs = {};
-                private _children = new Array();
+                private _children: unknown[] = [];
-                private _created: boolean = false;
+                private _created = false;
-                visitNext(v: any) {
+                visitNext(v: unknown) {
                     if (this._created)
                         throw new Error("The Element is already created");

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

                         } catch {
                             // guard
                         }
+                    };
                     this._cleanup.forEach(guard);
                     this._cleanup.length = 0;

djx/src/main/ts/tsx/WatchForRendition.ts +6 -6

                 component: (arg: T, index: number) => unknown;
             }
-            const isObservable = <T>(v: PromiseLike<ArrayLike<T>> | ArrayLike<T>): v is ArrayLike<T> & ObservableResults<T> =>
+            const isObservable = <T>(v: ArrayLike<T>): v is ArrayLike<T> & ObservableResults<T> =>
-                v && (typeof (v as any).observe === "function");
+                v && (typeof (v as { observe?: unknown; }).observe === "function");
             const noop = () => { };
                     this._ct = new Cancellation(cancel => scope.own(cancel));
                 }
-                private _onItemUpdated = (item: RenderTask<T>) => {
+                private readonly _onItemUpdated = (item: RenderTask<T>) => {
                     if (!this._renderTasks.length) {
                         // schedule a new job
                         this._renderTasks.push(item);
                         // update existing job
                         this._renderTasks.push(item);
                     }
+                };
                 private async _render() {
                     // fork
                     this._renderTasks.length = 0;
                 }
-                _onRenderItem = ({ item, newIndex, prevIndex, animate: _animate }: RenderTask<T>) => {
+                private readonly _onRenderItem = ({ item, newIndex, prevIndex, animate: _animate }: RenderTask<T>) => {
                     const animate = _animate && prevIndex !== newIndex;
                     if (prevIndex > -1) {
                         if (animate)
                             this._animateIn(nodes).catch(e => trace.error(e));
                     }
+                };
                 protected _getDomNode() {
                     if (!this._node)

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

                 addChild?(widget: unknown, index?: number): void;
             }
-            export type _WidgetCtor = new (attrs: {}, srcNode?: string | Node) => _Widget;
+            export type _WidgetCtor = new (attrs: object, srcNode?: string | Node) => _Widget;
             export class WidgetRendition extends RenditionBase<Node> {
                 readonly widgetClass: _WidgetCtor;

djx/src/main/ts/tsx/render.ts +10 -10

             let _context: Context = {
                 scope: Scope.dummy
+            };
             const guard = (cb: () => unknown) => {
                 try {
-                    const result = cb()
+                    const result = cb();
                     if (isPromise(result)) {
                         const warn = (ret: unknown) => trace.error("The callback {0} competed asynchronously. result = {1}", cb, ret);
                         result.then(warn, warn);
                 } catch (e) {
                     trace.error(e);
                 }
+            };
             export const beginRender = (scope: IScope = getScope()) => {
                 const prev = _context;
                     hooks: []
                 };
                 return endRender(prev);
+            };
             /**
              * Completes render operation
                     hooks.forEach(guard);
                 _context = prev;
+            };
             export const renderHook = (hook: () => void) => {
                 const { hooks } = _context;
                     hooks.push(hook);
                 else
                     guard(hook);
+            };
             export const refHook = <T>(value: T, ref: JSX.Ref<T>) => {
                 const { hooks, scope } = _context;
                     guard(() => ref(value));
                 scope.own(() => ref(undefined));
+            };
             /** Returns the current scope */
             export const getScope = () => _context.scope;
                 } finally {
                     complete();
                 }
+            };
             /** Renders DOM element for different types of the argument. */
             export const getItemDom = (v: unknown) => {
                     return fragment;
                 } else {
                     // bug: explicit error otherwise
-                    throw new Error("Invalid parameter: " + v);
+                    throw new Error(`Invalid parameter: ${String(v)}`);
                 }
+            };

djx/src/main/typings/index.d.ts +24 -16

+            // eslint-disable-next-line @typescript-eslint/triple-slash-reference
             /// <reference path="./css-plugin.d.ts"/>
-            declare namespace JSX {
+            import { Rendition } from "./tsx/traits";
+            declare global {
+                namespace JSX {
                     type Ref<T> = ((value: T | undefined) => void);
+                    type Element = Rendition;
                     interface DjxIntrinsicAttributes<E> {
                         /** alias for className */
-                    class: string;
+                        class?: string;
                         /** specifies the name of the property in the widget where the the
                          * reference to the current object will be stored
                          */
-                    "data-dojo-attach-point": string;
+                        "data-dojo-attach-point"?: string;
                         /** specifies handlers map for the events */
-                    "data-dojo-attach-event": string;
+                        "data-dojo-attach-event"?: string;
-                    ref: Ref<E>;
+                        ref?: Ref<E>;
                         /** @deprecated */
-                    [attr: string]: any;
+                        [attr: string]: unknown;
                     }
+                    // eslint-disable-next-line @typescript-eslint/no-empty-interface
                     interface DjxIntrinsicElements {
                     }
-                type RecursivePartial<T> = T extends string | number | boolean | null | undefined | Function ?
+                    type RecursivePartial<T> = T extends string | number | boolean | null | undefined | ((...args: unknown[]) => unknown) ?
                         T :
                         { [k in keyof T]?: RecursivePartial<T[k]> };
                     type ExcludeMembers<T, U> = Pick<T, NotMatchingMemberKeys<T, U>>;
-                type ElementAttrNames<E> = NotMatchingMemberKeys<E, (...args: any[]) => any>;
+                    type ElementAttrNames<E> = NotMatchingMemberKeys<E, (...args: unknown[]) => unknown>;
-                type ElementAttrType<E, K extends keyof any> = K extends keyof E ? RecursivePartial<E[K]> : string;
+                    type ElementAttrType<E, K extends string | symbol> = K extends keyof E ? RecursivePartial<E[K]> : string;
                     type ElementAttrNamesBlacklist = "children" | "getRootNode" | keyof EventTarget;
                      */
                     type AssignableElementAttrNames<E> = {
                         [K in keyof E]: K extends ElementAttrNamesBlacklist ? never :
-                        ((evt: Event) => any) extends E[K] ? K :
+                        ((evt: Event) => unknown) extends E[K] ? K :
-                        E[K] extends ((...args: any[]) => any) ? never :
+                        E[K] extends ((...args: unknown[]) => unknown) ? never :
                         K;
                     }[keyof E];
                     type LaxElement<E extends object> =
-                    Pick<E, AssignableElementAttrNames<E>> &
+                        RecursivePartial<Pick<E, AssignableElementAttrNames<E>>> &
                         DjxIntrinsicAttributes<E>;
                     type LaxIntrinsicElementsMap = {
                     } & DjxIntrinsicElements;
                     type IntrinsicElements = {
-                    [tag in keyof LaxIntrinsicElementsMap]: RecursivePartial<LaxIntrinsicElementsMap[tag]>;
+                        [tag in keyof LaxIntrinsicElementsMap]: LaxIntrinsicElementsMap[tag];
+                    };
                     interface ElementChildrenAttribute {
-                    children: {};
+                        children: unknown;
                     }
                     interface IntrinsicClassAttributes<T> {
-                    ref?: (value: T) => void;
+                        ref?: Ref<T>;
                         children?: unknown;
                     }
                 }
+            }
  No newline at end of file

djx/src/test/ts/view/MyWidget.tsx +27 -10

             import { DjxWidgetBase } from "../tsx/DjxWidgetBase";
             import { createElement, on } from "../tsx";
+            import { argumentNotNull } from "@implab/core-amd/safe";
             interface MyWidgetAttrs {
                 title: string;
                 };
             }
+            interface FrameProps {
+                ref?: JSX.Ref<HTMLDivElement>;
+                children?: unknown[];
+            }
+            const Frame = ({children, ref}: FrameProps) => <div ref={ref} >{children}</div>;
             @djclass
             export class MyWidget extends djbase(DjxWidgetBase as AbstractConstructor<DjxWidgetBase<MyWidgetAttrs, MyWidgetEvents>>) {
                 @prototype(0)
                 counter = 0;
+                frameNode?: HTMLDivElement;
                 render() {
-                    const Frame = ({children, ref}: {ref: JSX.Ref<HTMLDivElement>, children: unknown[]}) => <div ref={ref} >{children}</div>;
-                    return <div className="myWidget" onsubmit={e => this._onSubmit(e)} tabIndex={3} style={{ alignContent: "center", border: "1px solid" }} >
+                    return <div className="myWidget" onsubmit={this._onSubmit} tabIndex={3} style={{ alignContent: "center", border: "1px solid" }} >
                         <h1 data-dojo-attach-point="titleNode"></h1>
-                        <Frame ref={ v => {}}>
+                        <Frame ref={this._setFrameElement}>
-                            <span class="up-button" onclick={e => this._onIncClick(e)}>[+]</span>
+                            <span class="up-button" onclick={this._onIncClick}>[+]</span>
                             <span class="down-button" onclick={() => this._onDecClick()}>[-]</span>
                         </Frame>
                     </div>;
                 }
+                private readonly _setFrameElement = (node?: HTMLDivElement) => {
+                    this.frameNode = node;
+                };
                 postCreate() {
                     super.postCreate();
                     this.on("click", () => {});
                 }
-                _onSubmit(e: Event) {
+                private readonly _onSubmit = (evt: Event) => {
+                    argumentNotNull(evt, "evt");
+                };
-                _onIncClick(e: MouseEvent) {
+                private readonly _onIncClick = (evt: MouseEvent) => {
+                    argumentNotNull(evt, "evt");
                     this.set("counter", this.counter + 1);
                     this.emit("count-inc", { bubbles: false });
+                };
                 _onDecClick() {
                     this.emit("count-dec", { bubbles: false, detail: this.counter });
                 @on("count-inc")
                 private _onCounterInc(evt: Event & { detail: number; x?: number; }) {
+                    argumentNotNull(evt, "evt");
                 }
                 @on("click", "keydown")
-                protected _onClick(event: MouseEvent | KeyboardEvent) {
+                protected _onClick(evt: MouseEvent | KeyboardEvent) {
+                    argumentNotNull(evt, "evt");
                 }
             }

djx/src/test/tsconfig.json +7 -1

             {
                 "extends": "../tsconfig",
                 "compilerOptions": {
+                    "baseUrl": ".",
                     "noUnusedLocals": false,
                     //"rootDir": "ts",
                     "rootDirs": [
                         "../main/ts",
                         "../main/typings"
                     ],
-                    "types": ["requirejs", "../main/typings", "@implab/dojo-typings"]
+                    "types": [
+                        "requirejs",
+                        "../main/typings",
+                        "@implab/dojo-typings",
+                        "@implab/dojo-typings/dojo/NodeList-fx"
+                    ]
                 }
             }

djx/src/tsconfig.eslint.json +2 -3

             {
-                "extends": "./tsconfig.json",
+                //"extends": "./tsconfig.json",
                 "compilerOptions": {
                     // ensure that nobody can accidentally use this config for a build
-                    "noEmit": true
+                    "noEmit": true,
                 },
                 "include": [
-                    "ts"
                 ]
             }

playground/src/main/ts/main.ts +3 -3

             import MainWidget from "./view/MainWidget";
-            import "@implab/djx/css!dojo/resources/dojo.css"
+            import "@implab/djx/css!dojo/resources/dojo.css";
-            import "@implab/djx/css!dijit/themes/dijit.css"
+            import "@implab/djx/css!dijit/themes/dijit.css";
-            import "@implab/djx/css!dijit/themes/tundra/tundra.css"
+            import "@implab/djx/css!dijit/themes/tundra/tundra.css";
             const w = new MainWidget();
             w.placeAt(document.body);

playground/src/main/ts/model/MainContext.ts +12 -11

             import { Uuid } from "@implab/core-amd/Uuid";
             import { Observable as RxjsObservable } from "rxjs";
             import { QueryResultUpdate } from "@implab/djx/tsx";
+            import {isPromise} from "@implab/core-amd/safe";
             type AppointmentRecord = Omit<Appointment, "getMembers"> & {id: string};
             }
-            export function isObservable<T>(v: PromiseLike<ArrayLike<T>> | ArrayLike<T>): v is ArrayLike<T> & ObservableResults<T> {
+            export function isObservable<T>(v: unknown): v is ObservableResults<T> {
-                return v && (typeof (v as any).observe === "function");
+                return !!v && (typeof (v as {observe?: unknown}).observe === "function");
             }
             export function observe<T>(results: T[], includeObjectUpdates?: boolean): RxjsObservable<QueryResultUpdate<T>>;
             export function observe<T>(results: PromiseLike<T[]>, includeObjectUpdates?: boolean): PromiseLike<RxjsObservable<QueryResultUpdate<T>>>;
-            export function observe(results: any, includeObjectUpdates = true) {
+            export function observe(results: unknown[] | PromiseLike<unknown[]>, includeObjectUpdates = true) {
                 // results может быть асинхронным, т.е. до завершения
                 // получения результатов store может быть обновлен. В любом
                 // случае, если между подключением хотя бы одного наблюдателя
                 //    о необработанной ошибке в Promise при обращении к методам
                 //    обновления (add,put,remove)
-                const _subscribe = (items: any[]) => new RxjsObservable<QueryResultUpdate<any>>(subscriber => {
+                const _subscribe = (items: unknown[]) => new RxjsObservable<QueryResultUpdate<unknown>>(subscriber => {
                     items
                         .forEach((value, newIndex) => subscriber.next({ item: value, newIndex, prevIndex: -1}));
             export class MainContext {
-                private _appointments = new Observable(new Memory<AppointmentRecord>());
+                private readonly _appointments = new Observable(new Memory<AppointmentRecord>());
-                private _contacts = new Observable(new Memory<ContactRecord>());
+                private readonly _contacts = new Observable(new Memory<ContactRecord>());
-                private _members = new Observable(new Memory<MemberRecord>());
+                private readonly _members = new Observable(new Memory<MemberRecord>());
                 createAppointment(title: string, startAt: Date, duration: number, members: Member[]) {
                     const id = Uuid();
                         this._members.add({
                             appointmentId: id,
                             ...member
-                        }, {id: Uuid()})
+                        }, {id: Uuid()}) as void
                     );
                 }
                 queryAppointments(dateFrom: Date, dateTo: Date) {
-                    this._appointments.query().map()
+                    //this._appointments.query().map()
                 }
-                private _mapAppointment = ({startAt, title, duration, id}: AppointmentRecord) => ({
+                private readonly _mapAppointment = ({startAt, title, duration, id}: AppointmentRecord) => ({
-                })
+                });
             }

playground/src/main/ts/view/MainWidget.tsx +6 -6

             import Button = require("dijit/form/Button");
             import { interval } from "rxjs";
+            const Counter = ({ children }: { children: unknown[] }) => <span>Counter: {children}</span>;
             @djclass
             export default class MainWidget extends djbase(DjxWidgetBase) {
                 paused = false;
                 render() {
-                    const Counter = ({ children }: { children: unknown[] }) => <span>Counter: {children}</span>;
                     return <div className="tundra">
                         <h2 ref={attach(this, "titleNode")}>Hi!</h2>
                                     <Counter><input ref={all(
                                         bind("value", prop(this, "count")
                                             .map(x => x/10)
-                                            .map(String)
                                         ),
                                         attach(this, "counterNode")
                                     )} /> <span>s</span></Counter>,
                     });
                 }
-                private _onPauseClick = () => {
+                private readonly _onPauseClick = () => {
                     this.set("paused", !this.paused);
+                };
-                private _onToggleCounterClick = () => {
+                private readonly _onToggleCounterClick = () => {
                     this.set("showCounter", !this.showCounter);
+                };
             }

playground/src/test/ts/index.ts +1 0

	@@ -0,0 +1,1
				1	/* noop */ No newline at end of file

playground/src/tsconfig.eslint.json 0 -1

                     "noEmit": true
                 },
                 "include": [
-                    "ts"
                 ]
             }

djx/.eslintrc.json removed 0 -35

	@@ -1,35 +0,0
	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": "djx/src",
	17	"project": ["tsconfig.eslint.json", "*/tsconfig.json"]
	18	},
	19	"plugins": [
	20	"@typescript-eslint"
	21	],
	22	"rules": {
	23	"react/react-in-jsx-scope": "off",
	24	"react/no-unknown-property": "off",
	25	"@typescript-eslint/no-empty-function": "off",
	26	"max-classes-per-file": [
	27	"error",
	28	{ "ignoreExpressions": true, "max": 1 }
	29	],
	30	"@typescript-eslint/prefer-readonly": ["error"],
	31	"semi": "off",
	32	"@typescript-eslint/semi": ["error"]
	33
	34	}
	35	}

djx/src/test/ts/i18n/foo.ts removed 0 -9

	@@ -1,9 +0,0
	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	});
	9

djx/src/test/ts/i18n/ru/foo.ts removed 0 -6

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

playground/.eslintrc.json removed 0 -33

	@@ -1,33 +0,0
	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	}

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