implab/implabjs-djx Commit - r109:4a375b9c654a

linting

cin -

r109:4a375b9c654a default

parent child

Context file:

r109:4a375b9c654a

Expand all files

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

.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 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/test/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

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 +1 -1

             {
                 "name": "@implab/djx",
                 "version": "0.0.1-dev",
                 "description": "Supports using dojo version 1 with typescript and .tsx files",
                 "keywords": [
                     "dojo",
                     "tsx",
                     "typescript",
                     "widgets"
                 ],
                 "author": "Implab team",
                 "license": "BSD-2-Clause",
                 "repository": "https://code.implab.org/implab/implabjs-djx",
                 "publishConfig": {
                     "access": "public"
                 },
                 "peerDependencies": {
                     "@implab/core-amd": "^1.4.0",
                     "dojo": "^1.10.0"
                 },
                 "devDependencies": {
                     "@implab/core-amd": "^1.4.0",
                     "@types/chai": "4.1.3",
                     "@types/requirejs": "2.1.31",
                     "@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",
                     "eslint-config-standard": "^17.0.0",
                     "eslint-plugin-import": "^2.26.0",
                     "eslint-plugin-n": "^15.2.0",
                     "eslint-plugin-promise": "^6.0.0",
                     "eslint-plugin-react": "^7.29.4",
                     "requirejs": "2.3.6",
                     "typescript": "4.8.3",
                     "yaml": "~1.7.2",
                     "tap": "16.3.0"
                 }
             }

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

             import { MapOf, PromiseOrValue } from "@implab/core-amd/interfaces";
             import { argumentNotEmptyString, isPromise, mixin } from "@implab/core-amd/safe";
             export type LocaleProvider<T> = () => PromiseOrValue<T | { default: T }>;
-            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>>;
                 constructor(defNls: T, locales?: MapOf<LocaleProvider<Partial<T>>>) {
                     this._default = defNls;
                     this._locales = locales || {};
                     this._cache = {};
                 }
                 getLocale(locale: string) {
                     argumentNotEmptyString(locale, "locale");
                     const _loc = locale;
                     // en-US => ["en", "en-US"]
                     const locales = _loc.split(/-|_/).map((x, i, a) => a.slice(0, i + 1).join("-"));
                     return this._resolveLocale(locales);
                 }
                 _resolveLocale(locales: string[]): PromiseOrValue<T> {
                     if (!locales.length)
                         return this._default;
                     const locale = locales.pop();
                     if (!locale)
                         throw new Error("The locale can't be empty");
                     if (this._cache[locale])
                         return this._cache[locale];
                     const data = this._loadPackage(this._locales[locale]);
                     const parent = this._resolveLocale(locales);
                     return this._cache[locale] = when(data, x => {
                         return when(parent, y => this._cache[locale] = chainObjects(y, x));
                     });
                 }
-                _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 = {
                 load: (id: string, require: Require, cb: OnLoad, config: { isBuild?: boolean }) => {
                     if (config && config.isBuild) {
                         cb();
                     } else {
                         const url = require.toUrl(id);
                         inject.injectStylesheet(url).then(() => cb({ url }), e => cb.error(e));
                     }
                 }
             };
             export = plugin;

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

             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 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);
                         }
                     });
                     // 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 <K extends string>(target: Record<K, unknown>, name: K) => {
                         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;
                             };
                     };
                 }
             }
             /** Создает в прототипе свойство с указанным значением.
              * @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: { [m in string]: T | undefined }, name: string) => {
                     p[name] = value;
                 };
             }

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

             import { id as mid } from "module";
             import { TraceSource } from "@implab/core-amd/log/TraceSource";
             import { MapOf } from "@implab/core-amd/interfaces";
             import { mixin } from "@implab/core-amd/safe";
             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);
                 return () => node.removeEventListener(eventName, handler, false);
             }
             interface NodeLoadResult {
                 node: HTMLElement;
             }
             class DomInject {
                 injectionPoint?: HTMLElement;
                 injectAfter?: HTMLElement;
                 _map: MapOf<Promise<NodeLoadResult>> = {};
                 _inject<T extends keyof HTMLElementTagNameMap>(name: T, attr: Partial<HTMLElementTagNameMap[T]>) {
                     const node = document.createElement(name);
                     return new Promise<NodeLoadResult>((ok, fail) => {
                         const cleanup = () => {
                             noerr();
                             noload();
                         };
                         const noload = on(node, "load", () => {
                             ok({ node });
                             cleanup();
                         });
                         const noerr = on(node, "error", e => {
                             fail({
                                 error: e,
                                 node
                             });
                             cleanup();
                         });
                         mixin(node, attr);
                         const _injectionPoint = this.injectionPoint || document.head;
                         const _injectBefore = this.injectAfter ? this.injectAfter.nextSibling : null;
                         _injectionPoint.insertBefore(node, _injectBefore);
                     });
                 }
                 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",
                             charset: "utf-8",
                             src: url
                         });
                         this._map[url] = d;
                     }
                     try {
                         await d;
                         trace.log("done {0}", url);
                     } catch (e) {
                         trace.error("failed {0}: {1}", url, e);
                         throw e;
                     }
                 }
                 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",
                             rel: "stylesheet",
                             href: url
                         });
                         this._map[url] = d;
                     }
                     try {
                         await d;
                         trace.log("done {0}", url);
                     } catch (e) {
                         trace.error("failed {0}: {1}", url, e);
                         throw e;
                     }
                 }
             }
             const instance = new DomInject();
             export default instance;

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";
             const trace = TraceSource.get(mid);
             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) => {
                     const locale = _locale || sysLocale;
                     const result = nlsBundle.getLocale(locale);
                     if (isPromise(result))
                         throw new Error(`The bundle '${locale}' isn't loaded`);
                     else
                         return result;
                 };
                 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();
                     } else {
                         try {
                             await nlsBundle.getLocale(locale);
                             cb();
                         } catch (e) {
                             if(cb.error) {
                                 cb.error(e);
                             } else {
                                 // in case the loader doesn't support error reporting
                                 trace.error("Error loading {0}: {1}", locale, e);
                             }
                         }
                     }
                 };
                 return fn;
             }

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

             /**
              * The interface for the consumer of an observable sequence
              */
             export interface Observer<T> {
                 /**
                  * Called for the next element in the sequence
                  */
                 next: (value: T) => void;
                 /**
                  * Called once when the error occurs in the sequence.
                  */
                 error: (e: unknown) => void;
                 /**
                  * Called once at the end of the sequence.
                  */
                 complete: () => void;
             }
             /**
              * The group of functions to feed an observable. This methods are provided to
              * the producer to generate a stream of events.
              */
             export type Sink<T> = {
                 [k in keyof Observer<T>]: (this: void, ...args: Parameters<Observer<T>[k]>) => void;
             };
             export type Producer<T> = (sink: Sink<T>) => (void | (() => void));
             export interface Unsubscribable {
                 unsubscribe(): void;
             }
             export const isUnsubsribable = (v: unknown): v is Unsubscribable =>
                 v !== null && v !== undefined && typeof (v as Unsubscribable).unsubscribe === "function";
             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> {
                 subscribe(consumer: Partial<Observer<T>>): Unsubscribable;
             }
             /** The observable source of items. */
             export interface Observable<T> extends Subscribable<T> {
                 /** Transforms elements of the sequence with the specified mapper
                  *
                  * @param mapper The mapper used to transform the values
                  */
                 map<T2>(mapper: (value: T) => T2): Observable<T2>;
                 /** Filters elements of the sequence. The resulting sequence will
                  * contain only elements which match the specified predicate.
                  *
                  * @param predicate The filter predicate.
                  */
                 filter(predicate: (value: T) => boolean): Observable<T>;
                 /** Applies accumulator to each value in the sequence and
                  * emits the accumulated value for each source element
                  *
                  * @param accumulator
                  * @param initial
                  */
                 scan<A>(accumulator: (acc: A, value: T) => A, initial: A): Observable<A>;
             }
             const noop = () => { };
             const sink = <T>(consumer: Partial<Observer<T>>) => {
                 const { next, error, complete } = consumer;
                 return {
                     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>>) => ({
                     unsubscribe: producer(sink(consumer)) ?? noop
                 }),
                 map: (mapper) => _observe(({ next, error, complete }) =>
                     producer({
                         next: next !== noop ? (v: T) => next(mapper(v)) : noop,
                         error,
                         complete
                     })
                 ),
                 filter: (predicate) => _observe(({ next, error, complete }) =>
                     producer({
                         next: next !== noop ?
                             (v: T) => predicate(v) ? next(v) : void (0) : noop,
                         error,
                         complete
                     })
                 ),
                 scan: (accumulator, initial) => _observe(({ next, error, complete }) => {
                     let _acc = initial;
                     return producer({
                         next: next !== noop ?
                             (v: T) => next(_acc = accumulator(_acc, v)) : noop,
                         error,
                         complete
                     });
                 })
             });
             export const observe = <T>(producer: Producer<T>): Observable<T> => ({
                 subscribe: (consumer: Partial<Observer<T>>) => ({
                     unsubscribe: producer(fuse(sink(consumer))) ?? noop
                 }),
                 map: (mapper) => _observe(({ next, error, complete }) =>
                     producer(fuse({
                         next: next !== noop ?
                             (v: T) => next(mapper(v)) : noop,
                         error,
                         complete
                     }))
                 ),
                 filter: (predicate) => _observe(({ next, error, complete }) =>
                     producer(fuse({
                         next: next !== noop ?
                             (v: T) => predicate(v) ? next(v) : void (0) : noop,
                         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,
                         error,
                         complete
                     }));
                 })
             });

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

djx/src/main/ts/tsx/DjxWidgetBase.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

djx/src/main/ts/tsx/FunctionRendition.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

djx/src/main/ts/tsx/RenditionBase.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

djx/src/main/ts/tsx/Scope.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

djx/src/main/ts/tsx/WatchForRendition.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

djx/src/main/ts/tsx/WidgetRendition.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

djx/src/main/ts/tsx/render.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

djx/src/main/typings/index.d.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

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

djx/src/test/tsconfig.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/tsconfig.eslint.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/model/MainContext.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/MainWidget.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

playground/src/test/ts/index.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/tsconfig.eslint.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/.eslintrc.json removed 0 -35

NO CONTENT: file was removed

djx/src/test/ts/i18n/foo.ts 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

djx/src/test/ts/i18n/ru/foo.ts 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

playground/.eslintrc.json 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