implab/implabjs-djx Commit - r108:d644dced936e

linting

cin -

r108:d644dced936e default

parent child

Context file:

r108:d644dced936e

Collapse all files

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

djx/.eslintrc.json +2 0

             {
                 "root": true,
                 "extends": [
                     "plugin:react/recommended",
                     "eslint:recommended",
                     "plugin:@typescript-eslint/eslint-recommended",
                     "plugin:@typescript-eslint/recommended",
                     "plugin:@typescript-eslint/recommended-requiring-type-checking"
                 ],
                 "parser": "@typescript-eslint/parser",
                 "parserOptions": {
                     "ecmaFeatures": {
                         "jsx": true
                     },
                     "ecmaVersion": 5,
                     "tsconfigRootDir": "djx/src",
                     "project": ["tsconfig.eslint.json", "*/tsconfig.json"]
                 },
                 "plugins": [
                     "@typescript-eslint"
                 ],
                 "rules": {
+                    "react/react-in-jsx-scope": "off",
+                    "react/no-unknown-property": "off",
                     "@typescript-eslint/no-empty-function": "off",
                     "max-classes-per-file": [
                         "error",
                         { "ignoreExpressions": true, "max": 1 }
                     ],
                     "@typescript-eslint/prefer-readonly": ["error"],
                     "semi": "off",
                     "@typescript-eslint/semi": ["error"]
                 }
             }

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/src/main/ts/declare.ts +12 -16

             import declare = require("dojo/_base/declare");
             import { each } from "@implab/core-amd/safe";
             import { Constructor } from "@implab/core-amd/interfaces";
             // declare const declare: any;
             type DeclareConstructor<T> = dojo._base.DeclareConstructor<T>;
             export interface AbstractConstructor<T = object> {
                 prototype: T;
             }
             interface DjMockConstructor<T = object> {
                 new(...args: unknown[]): T;
                 mock: boolean;
                 bases: AbstractConstructor[];
             }
             export function djbase<T>(): DeclareConstructor<T>;
             export function djbase<T>(
                 b0: AbstractConstructor<T>
             ): DeclareConstructor<T>;
             export function djbase<T0, T1>(
                 b0: AbstractConstructor<T0>,
                 b1: AbstractConstructor<T1>
             ): DeclareConstructor<T0 & T1>;
             export function djbase<T0, T1, T2>(
                 b0: AbstractConstructor<T0>,
                 b1: AbstractConstructor<T1>,
                 b2: AbstractConstructor<T2>
             ): DeclareConstructor<T0 & T1 & T2>;
             export function djbase<T0, T1, T2, T3>(
                 b0: AbstractConstructor<T0>,
                 b1: AbstractConstructor<T1>,
                 b2: AbstractConstructor<T2>,
                 b3: AbstractConstructor<T3>
             ): DeclareConstructor<T0 & T1 & T2 & T3>;
             export function djbase<T0, T1, T2, T3, T4>(
                 b0: AbstractConstructor<T0>,
                 b1: AbstractConstructor<T1>,
                 b2: AbstractConstructor<T2>,
                 b3: AbstractConstructor<T3>,
                 b4: AbstractConstructor<T4>
             ): DeclareConstructor<T0 & T1 & T2 & T3 & T4>;
             export function djbase<T0, T1, T2, T3, T4, T5>(
                 b0: AbstractConstructor<T0>,
                 b1: AbstractConstructor<T1>,
                 b2: AbstractConstructor<T2>,
                 b3: AbstractConstructor<T3>,
                 b4: AbstractConstructor<T4>,
                 b5: AbstractConstructor<T5>
             ): DeclareConstructor<T0 & T1 & T2 & T3 & T4 & T5>;
             export function djbase<T0, T1, T2, T3, T4, T5, T6>(
                 b0: AbstractConstructor<T0>,
                 b1: AbstractConstructor<T1>,
                 b2: AbstractConstructor<T2>,
                 b3: AbstractConstructor<T3>,
                 b4: AbstractConstructor<T4>,
                 b5: AbstractConstructor<T5>,
                 b6: AbstractConstructor<T6>
             ): DeclareConstructor<T0 & T1 & T2 & T3 & T4 & T5 & T6>;
             export function djbase<T0, T1, T2, T3, T4, T5, T6, T7>(
                 b0: AbstractConstructor<T0>,
                 b1: AbstractConstructor<T1>,
                 b2: AbstractConstructor<T2>,
                 b3: AbstractConstructor<T3>,
                 b4: AbstractConstructor<T4>,
                 b5: AbstractConstructor<T5>,
                 b6: AbstractConstructor<T6>,
                 b7: AbstractConstructor<T7>
             ): DeclareConstructor<T0 & T1 & T2 & T3 & T4 & T5 & T6 & T7>;
             /** Создает конструктор-заглушку из списка базовых классов, используется
              * для объявления классов при помощи `dojo/_base/declare`.
              *
              * Создает пустой конструктор, с пустым стандартным прототипом, это нужно,
              * поскольку в унаследованном классе конструктор обязательно должен вызвать
              * `super(...)`, таким образом он вызовет пустую функцию.
              *
              * Созданный конструктор хранит в себе список базовых классов, который будет
              * использован декоратором `djclass`, который вернет класс, объявленный при
              * помощи `dojo/_base/declare`.
              *
              * @param bases список базовых классов, от которых требуется унаследовать
              *  новый класс.
              *
              */
             export function djbase(...bases: AbstractConstructor[]): Constructor {
                 const t = class {
                     static mock: boolean;
                     static bases: AbstractConstructor[];
                 };
                 t.mock = true;
                 t.bases = bases;
                 return t as Constructor;
             }
             function isMockConstructor<T extends object>(v: AbstractConstructor<T>): v is DjMockConstructor<T> {
                 return v && "mock" in v;
             }
             /** Создает класс при помощи `dojo/_base/declare`. Для этого исходный класс
              * должен быть унаследован от `djbase(...)`.
              *
              * @param target Класс, который нужно объявить при помощи `dojo/_base/declare`
              */
             export function djclass<T extends AbstractConstructor>(target: T): T {
                 // получаем базовый конструктор и его прототип
                 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(bc.bases, target.prototype) as unknown as T;
                     // bc - базовый класс, bc.prototype используется как super
                     // при вызове базовых методов. Нужно создать bc.prototype
                     // таким образом, чтобы он вызывал this.inherited().
                     // создаем новый прототип, он не в цепочке прототипов у текущего
                     // класса, но super.some_method будет использовать именно его.
                     // в этом объекте будут размещены прокси для переопределенных
                     // методов.
                     const nbp = bc.prototype = Object.create(cls.prototype) as Record<string, unknown>;
                     nbp.constructor = bc;
                     // proxy - фабрика для создания прокси-методов, которые внутри
                     // себя вызовут this.inherited с правильными параметрами.
                     const proxy = (m: (...args: unknown[]) => unknown) => function (this: dojo._base.DeclareCreatedObject, ...args: unknown[]) {
-                        const f = this.getInherited({ callee: m, ...args, length: args.length});
+                        const f = this.getInherited({ callee: m, ...args, length: args.length });
                         return f ? f.apply(this, args) 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)
                         ) {
                             nbp[p] = proxy(m as (...args: unknown[]) => unknown);
                         }
                     });
                     // TODO mixin static members
                     return cls;
                 } else {
                     return target;
                 }
             }
             function makeSetterName(prop: string) {
                 return [
                     "_set",
                     prop.replace(/^./, x => x.toUpperCase()),
                     "Attr"
                 ].join("");
             }
             function makeGetterName(prop: string) {
                 return [
                     "_get",
                     prop.replace(/^./, x => x.toUpperCase()),
                     "Attr"
                 ].join("");
             }
             interface NodeBindSpec {
                 node: string;
                 type: "attribute" | "innerText" | "textContent" | "innerHTML" | "class" | "toggleClass";
                 attribute?: string;
                 className?: string;
             }
             /**
              *  Описание привязки свойства виджета к свойству внутреннего объекта.
              */
             interface MemberBindSpec {
                 /**
                  * Имя свойства со ссылкой на объект, к которому .
                  */
                 member: string;
                 /**
                  * Свойство объекта к которому нужно осуществить привязку.
                  */
                 property: string;
                 /**
                  * Привязка осуществляется не только на запись но и на чтение свойства.
                  */
                 getter?: boolean;
             }
             function isNodeBindSpec(v: object): v is NodeBindSpec {
                 return "node" in v;
             }
             /** Декорирует свойства виджета для привязки их к внутренним членам, либо DOM
              * элементам, либо свойству внутреннего объекта.
              *
              * @param {NodeBindSpec | MemberBindSpec} params Параметры связывания.
              */
             export function bind(params: NodeBindSpec | MemberBindSpec) {
                 if (isNodeBindSpec(params)) {
-                    return (target: Record<string, unknown>, name: string) => {
+                    return <K extends string>(target: Record<K, unknown>, name: K) => {
-                        target[makeSetterName(name)] = params;
+                        target[makeSetterName(name) as K /** hack to not go insane) */] = params;
                     };
                 } else {
-                    return (target: Record<string, unknown> & { _set(name: string, v: unknown): void }, name: string) => {
+                    return <K extends string,
-                        target[name] = null;
+                        T extends { [p in K]: p extends "_set" ? (name: p, v: unknown) => void : unknown; }> (target: T, name: K) => {
-                        target[makeSetterName(name)] = function (v: unknown) {
+                        target[name] = undefined as T[K];
+                        target[makeSetterName(name) as K] = function (this: T, v: unknown) {
                             this._set(name, v);
                             const inner = this[params.member] as Record<string, unknown>;
                             if (typeof inner.set === "function")
                                 inner.set(params.property, v);
-                        };
+                        } as T[K];
                         if (params.getter)
                             target[makeGetterName(name)] = function () {
                                 const inner = this[params.member] as Record<string, unknown>;
                                 if (typeof inner.get === "function")
                                     return inner.get(params.property) as unknown;
                             };
                     };
                 }
             }
-            /** Создает в прототипе указанное свойство со значение `undefined`, данный
-             * декоратор следует использовать для свойств, у которых нет значения по-умолчанию
-             * и они не могут быть `null | undefined`
-             */
-            export function prototype(): (p: object, name: string) => void;
             /** Создает в прототипе свойство с указанным значением.
              * @param value Значение, которое будет указано в прототипе
              */
             export function prototype<T>(value: T): <P extends { [m in K]: T }, K extends keyof P>(p: P, name: K) => void;
             export function prototype<T>(value?: T) {
-                return <P extends { [m in K]: T }, K extends keyof P>(p: P, name: K) => {
+                return (p: { [m in string]: T | undefined }, name: string) => {
-                    p[name] = value as any;
+                    p[name] = value;
                 };
             }

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

             import { IDestroyable } from "@implab/core-amd/interfaces";
             import { isDestroyable } from "@implab/core-amd/safe";
             import _WidgetBase = require("dijit/_WidgetBase");
             import registry = require("dijit/registry");
             interface _WidgetBaseConstructor {
-                new <E extends { [k in keyof E]: Event } = {}>(params?: Partial<_WidgetBase<E>> & ThisType<_WidgetBase<E>>, srcNodeRef?: string | Node): _WidgetBase<E> & dojo._base.DeclareCreatedObject;
+                new <E extends { [k in keyof E]: Event } = object>(params?: Partial<_WidgetBase<E>> & ThisType<_WidgetBase<E>>, srcNodeRef?: string | Node): _WidgetBase<E> & dojo._base.DeclareCreatedObject;
                 prototype: _WidgetBase;
             }
             export type DojoNodePosition = "first" | "after" | "before" | "last" | "replace" | "only" | number;
             export type DojoNodeLocation = [Node, DojoNodePosition];
             export interface Rendition<TNode extends Node = Node> {
                 getDomNode(): TNode;
                 placeAt(refNode: string | Node, position?: DojoNodePosition): void;
             }
             /**
              * @deprecated use Rendition
              */
             export type BuildContext<TNode extends Node = Node> = Rendition<TNode>;
             export interface IRecursivelyDestroyable {
                 destroyRecursive(): void;
             }
             export const isNode = (el: unknown): el is Node => !!(el && (el as Node).nodeName && (el as Node).nodeType);
             export const isElementNode = (el: unknown): el is Element => isNode(el) && el.nodeType === 1;
             export const isTextNode = (el: unknown): el is Text => isNode(el) && el.nodeType === 3;
             export const isProcessingInstructionNode = (el: unknown): el is ProcessingInstruction => isNode(el) && el.nodeType === 7;
             export const isCommentNode = (el: unknown): el is Comment => isNode(el) && el.nodeType === 8;
             export const isDocumentNode = (el: unknown): el is Document => isNode(el) && el.nodeType === 9;
             export const isDocumentTypeNode = (el: unknown): el is DocumentType => isNode(el) && el.nodeType === 10;
             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));
             export const isRendition = (v: unknown): v is Rendition => !!(v && typeof (v as Rendition).getDomNode === "function");
             /**
              * @deprecated use isRendition
              */
             export const isBuildContext = isRendition;
             export const isPlainObject = (v: object) => {
                 if (typeof v !== "object")
                     return false;
                 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 && (
                     "domNode" in v.prototype ||
                     "buildRendering" in v.prototype
                 );
             /** Tests whether the specified node is placed in visible dom.
              *  @param {Node} node The node to test
              */
             export const isInPage = (node: Node) => node === document.body ? false : document.body.contains(node);
             export const isRecursivelyDestroyable = (target: unknown): target is IRecursivelyDestroyable =>
                 !!(target && typeof (target as IRecursivelyDestroyable).destroyRecursive === "function");
             /** Destroys DOM Node with all contained widgets.
              * If the specified node is the root node of a widget, then the
              * widget will be destroyed.
              *
              * @param target DOM Node or widget to destroy
              */
             export const destroy = (target: Node | IDestroyable | IRecursivelyDestroyable) => {
                 if (isRecursivelyDestroyable(target)) {
                     target.destroyRecursive();
                 } else if (isDestroyable(target)) {
                     target.destroy();
                 } else if (isNode(target)) {
                     if (isElementNode(target)) {
                         const w = registry.byNode(target);
                         if (w) {
                             w.destroyRecursive();
                             return;
                         } else {
                             emptyNode(target);
                         }
                     }
                     const parent = target.parentNode;
                     if (parent)
                         parent.removeChild(target);
                 }
             };
             /** Empties a content of the specified node and destroys all contained widgets.
              *
              * @param target DOM node to empty.
              */
             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
              * associated with the widget that widget will be started.
              *
              * @param target DOM node to find and start widgets or the widget itself.
              */
             export const startupWidgets = (target: Node | _WidgetBase, skipNode?: Node) => {
                 if (isNode(target)) {
                     if (isElementNode(target)) {
                         const w = registry.byNode(target);
                         if (w) {
                             if (w.startup)
                                 w.startup();
                         } else {
                             registry.findWidgets(target, skipNode).forEach(x => x.startup());
                         }
                     }
                 } else {
                     if (target.startup)
                         target.startup();
                 }
             };
             /** Places the specified DOM node at the specified location.
              *
              * @param node The node which should be placed
              * @param refNodeOrId The reference node where the created
              *  DOM should be placed.
              * @param position  Optional parameter, specifies the
              *  position relative to refNode. Default is "last" (i.e. last child).
              */
             export const placeAt = (node: Node, refNodeOrId: string | Node, position: DojoNodePosition = "last") => {
                 const ref = typeof refNodeOrId == "string" ? document.getElementById(refNodeOrId) : refNodeOrId;
                 if (!ref)
                     return;
                 const parent = ref.parentNode;
                 if (typeof position == "number") {
                     if (ref.childNodes.length <= position) {
                         ref.appendChild(node);
                     } else {
                         ref.insertBefore(node, ref.childNodes[position]);
                     }
                 } else {
                     switch (position) {
                         case "before":
                             parent && parent.insertBefore(node, ref);
                             break;
                         case "after":
                             parent && parent.insertBefore(node, ref.nextSibling);
                             break;
                         case "first":
                             ref.insertBefore(node, ref.firstChild);
                             break;
                         case "last":
                             ref.appendChild(node);
                             break;
                         case "only":
                             emptyNode(ref);
                             ref.appendChild(node);
                             break;
                         case "replace":
                             if (parent)
                                 parent.replaceChild(node, ref);
                             destroy(ref);
                             break;
                     }
                 }
             };
             /** Collects nodes from collection to an array.
              *
              * @param collection The collection of nodes.
              * @returns The array of nodes.
              */
             export const collectNodes = (collection: NodeListOf<ChildNode>) => {
                 const items = [];
                 for (let i = 0, n = collection.length; i < n; i++) {
                     items.push(collection[i]);
                 }
                 return items;
             };
             export const isMounted = (node: Node) => {
                 if (node.parentNode) {
                     const parentWidget = registry.getEnclosingWidget(node.parentNode);
                     if (parentWidget && parentWidget._started)
                         return true;
                 }
                 if (isInPage(node))
                     return true;
                 return false;
             };

djx/src/test/ts/observable-tests.ts +5 -5

             import { observe } from "./observable";
             import * as t from "tap";
             const subj1 = observe<number>(({ next, complete }) => {
                 next(1);
                 complete();
                 next(2);
             });
             const consumer1 = {
                 sum: 0,
                 next(v: number) {
                     this.sum += v;
                 }
+            };
             subj1.subscribe(consumer1);
             t.equal(consumer1.sum, 1, "Should get only one value");
             subj1.subscribe(consumer1);
             t.equal(consumer1.sum, 2, "Should get the value again");
             const consumer2 = {
                 value: 0,
                 completed: false,
                 next(v: number) { this.value = v; },
                 complete() { this.completed = true; }
             };
             let maps = 0;
             subj1
                 .map(v => {
-                    t.comment("map1: " + v * 2);
+                    t.comment(`map1: ${v * 2}`);
                     maps++;
                     return v * 2;
                 })
                 .map (v => {
-                    t.comment("map2: " + v * 2);
+                    t.comment(`map2: ${v * 2}`);
                     maps++;
                     return v * 2;
                 })
                 .map(v => {
-                    t.comment("map3: " + v * 2);
+                    t.comment(`map3: ${v * 2}`);
                     maps++;
-                    return v * 2
+                    return v * 2;
                 })
                 .subscribe(consumer2);
             t.equal(consumer2.value, 8, "Should map");
             t.equal(maps, 3, "The map chain should not be executed after completion");
             t.ok(consumer2.completed, "The completion signal should pass through");

djx/src/test/ts/view/MyWidget.tsx 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