implab/implabjs-djx Commit - r15:8ef85ad13241

Working on dojo typings

cin -

r15:8ef85ad13241 default

parent child

Context file:

r15:8ef85ad13241

Collapse all files

build.gradle +6 -1

             configureTsMain {
                 compilerOptions {
-                    types = ["requirejs", "dojo-typings"]
+                    baseUrl = "$projectDir/src"
+                    paths = [
+                        "dojo/*" : [ "typings/dojo/*" ],
+                        "dijit/*" : [ "typings/dijit/*" ]
+                    ]
+                    types = ["requirejs", "$projectDir/src/typings/dojo/index" /*, "dojo-typings"*/]
                 }
             }

package-lock.json +3 -3

                         "dev": true
                     },
                     "typescript": {
-                        "version": "3.7.5",
+                        "version": "3.8.3",
-                        "resolved": "https://registry.npmjs.org/typescript/-/typescript-3.7.5.tgz",
+                        "resolved": "https://registry.npmjs.org/typescript/-/typescript-3.8.3.tgz",
-                        "integrity": "sha512-/P5lkRXkWHNAbcJIiHPfRoKqyd7bsyCma1hZNUGfn20qm64T6ZBlrzprymeu918H+mB/0rIg2gGK/BXkhhYgBw==",
+                        "integrity": "sha512-MYlEfn5VrLNsgudQTVJeNaQFUAI7DkhnOjdpAp4T+ku1TfQClewlbSuTVHiA+8skNBgaf02TL/kLOvig4y3G8w==",
                         "dev": true
                     },
                     "uri-js": {

package.json +1 -1

                 "devDependencies": {
                     "@types/requirejs": "2.1.31",
                     "dojo": "1.16.0",
-                    "typescript": "~3.7.5",
+                    "typescript": "~3.8.3",
                     "eslint": "6.8.0",
                     "tslint": "6.0.0",
                     "@implab/core-amd": "^1.3.2",

src/main/ts/declare.ts +3 -2

             import declare = require("dojo/_base/declare");
             import { each } from "@implab/core-amd/safe";
             import { Constructor } from "@implab/core-amd/interfaces";
-            // import { DeclareConstructor } from "dojo/_base/declare";
-            type DeclareConstructor<T> = dojo._base.DeclareConstructor<T>;
+            // declare const declare: any;
+            type DeclareConstructor<T> = declare.DeclareConstructor<T>;
             export interface AbstractConstructor<T = {}> {
                 prototype: T;

src/main/ts/tsx/DjxWidgetBase.ts +3 -2

             import _AttachMixin = require("dijit/_AttachMixin");
             import { BuildContext, isNode } from "./traits";
             import registry = require("dijit/registry");
-            // import { Handle } from "dojo/interfaces";
+            import { Handle } from "dojo/interfaces";
-            type Handle = dojo.Handle;
+            // type Handle = dojo.Handle;
             @djclass
             export abstract class DjxWidgetBase extends djbase(_WidgetBase, _AttachMixin) {

src/main/tsconfig.json +6 -1

             {
                 "extends": "../tsconfig",
                 "compilerOptions": {
+                    "baseUrl": "../",
                     "rootDir": "ts",
                     "rootDirs": [
                         "ts",
                         "typings"
                     ],
+                    "paths" : {
+                        "dojo/*" : [ "typings/dojo/*" ],
+                        "dijit/*" : [ "typings/dijit/*" ]
+                    },
                     "types": [
-                        "requirejs", "dojo-typings", "./typings/index"
+                        "requirejs", "./typings/index", "../typings/dojo/index"
                     ]
                 }
             }

src/test/ts/dummy.ts +1 -1

                 }, 100);
             });
-            test("simple", async log => {
+            test("simple", async (log, fail) => {
                 await delay(0);
                 assert.ok(true); // everything is fine

src/typings/dijit/_AttachMixin.d.ts +2 -2

-            import { DeclareConstructor } from "dojo/_base/declare";
             import { Handle } from "dojo/interfaces";
             import _WidgetBase = require("./_WidgetBase");
+            import declare = require("dojo/_base/declare");
             declare module "./_WidgetBase" {
                 interface _WidgetBase {
                 destroyRendering(preserveDom?: boolean): void;
             }
-            interface _AttachMixinConstructor extends DeclareConstructor<_AttachMixin> { }
+            interface _AttachMixinConstructor extends declare.DeclareConstructor<_AttachMixin> { }
             declare const _AttachMixin: _AttachMixinConstructor;
             export = _AttachMixin;

src/typings/dijit/_WidgetBase.d.ts +1 -2

             import Destroyable = require("./Destroyable");
             import { ExtensionEvent } from "dojo/on";
             import { NodeFragmentOrString, Handle, NodeOrString, WatchHandle } from "dojo/interfaces";
-            import { DeclareConstructor } from "dojo/_base/declare";
             declare namespace _WidgetBase {
                 interface _WidgetBase extends Stateful, Destroyable {
                 }
                 interface _WidgetBaseConstructor<W = _WidgetBase> extends DeclareConstructor<W> {
-                    new(params: Object, srcNodeRef: NodeOrString): W;
+                    new(params: Object, srcNodeRef?: NodeOrString): W;
                 }
             }

src/typings/dojo/_base/Color.d.ts +4 -4

             /* dojo/_base/Color */
-            declare namespace dojoColor {
+            declare namespace Color {
                 type ColorValue = [number, number, number];
                 type ColorValueAlpha = [number, number, number, number];
             }
-            type dojoColor = dojoColor.Color;
+            type Color = Color.Color;
-            declare const dojoColor: dojoColor.ColorConstructor;
+            declare const Color: Color.ColorConstructor;
-            export = dojoColor;
+            export = Color;

src/typings/dojo/_base/Deferred.d.ts +1 0

             import DojoPromise = require("../promise/Promise");
             import { PromiseCallback, PromiseErrback, PromiseProgback } from "../promise/Promise";
+            import declare = require("./declare");
             /* dojo/_base/Deferred */

src/typings/dojo/_base/array.d.ts +9 -13

             import { GenericConstructor } from "../interfaces";
             /* dojo/_base/array */
-            interface DojoArray {
             /**
              * Determines whether or not every item in arr satisfies the condition implemented by callback.
              * @param {T[] | string} arr the array to iterate on. If a string, operates on individual characters.
              *                                     array and returns true if the condition is met.
              * @param {object} thisObj may be used to scope the call to callback
              */
-                every<T>(arr: T[] | string, callback: string | ((item: T, idx: number, arr: T[]) => boolean), thisObj?: Object): boolean;
+            export function every<T>(arr: T[] | string, callback: string | ((item: T, idx: number, arr: T[]) => boolean), thisObj?: Object): boolean;
             /**
              * Determines whether or not any item in arr satisfies the condition implemented by callback.
              */
-                some<T>(arr: T[] | string, callback: string | ((item: T, idx: number, arr: T[]) => boolean), thisObj?: Object): boolean;
+            export function some<T>(arr: T[] | string, callback: string | ((item: T, idx: number, arr: T[]) => boolean), thisObj?: Object): boolean;
             /**
              * locates the last index of the provided value in the passed array. If the value is not found, -1
              * @param {boolean} findLast Makes indexOf() work like lastIndexOf().  Used internally; not meant
              *                           for external usage.
              */
-                indexOf<T>(arr: T[], value: T, fromIndex?: number, findLast?: boolean): number;
+            export function indexOf<T>(arr: T[], value: T, fromIndex?: number, findLast?: boolean): number;
             /**
              * locates the first index of the provided value in the passed array. If the value is not found,
              * -1 is returned.
              */
-                lastIndexOf<T>(arr: T[], value: T, fromIndex?: number): number;
+            export function lastIndexOf<T>(arr: T[], value: T, fromIndex?: number): number;
             /**
              * locates the last index of the provided value in the passed array. If the value is not found,
              * -1 is returned.
              */
-                forEach<T>(arr: T[], callback: string | ((item: T, idx: number, arr: T[]) => void), thisObj?: Object): void;
+            export function forEach<T>(arr: T[], callback: string | ((item: T, idx: number, arr: T[]) => void), thisObj?: Object): void;
             /**
              * for every item in arr, callback is invoked. Return values are ignored. If you want to break
              * out of the loop, consider using array.every() or array.some().
              */
-                map<T, U>(arr: T[] | string, callback: string | ((item: T, idx: number, arr: T[]) => U), thisObj?: Object, Ctr?: GenericConstructor<U[]>): U[];
+            export function map<T, U>(arr: T[] | string, callback: string | ((item: T, idx: number, arr: T[]) => U), thisObj?: Object, Ctr?: GenericConstructor<U[]>): U[];
             /**
              * Returns a new Array with those items from arr that match the condition implemented by
              * callback.
              */
-                filter<T>(arr: T[], callback: string | ((item: T, idx: number, arr: T[]) => boolean), thisObj?: Object): T[];
+            export function filter<T>(arr: T[], callback: string | ((item: T, idx: number, arr: T[]) => boolean), thisObj?: Object): T[];
-                clearCache(): void;
+            export function clearCache(): void;
-            declare const dojoArray: DojoArray;
-            export = dojoArray;

src/typings/dojo/_base/browser.d.ts +1 -1

             import "./xhr";
             import "./fx";
-            export = dojo;
  No newline at end of file
+            export = dojo;

src/typings/dojo/_base/config.d.ts +6 -3

             import { ColorValue, ColorValueAlpha } from "./Color";
             import { HasCache } from "../has";
+            declare namespace config {
                 interface Config {
                     /** Defaults to `false`. If set to `true`, ensures that Dojo provides
                      * extended debugging feedback via Firebug. If Firebug is not available
                     useDeferredInstrumentation: string | boolean | number;
                 }
-            type dojoConfig = Config;
-            declare const dojoConfig: Config;
-            export = dojoConfig;
  No newline at end of file
+            declare const config: config.Config;
+            export = config;

src/typings/dojo/_base/connect.d.ts +9 -11

             import { Handle } from "../interfaces";
-            interface Connect {
             /**
              * TODO: Type this better
              */
-                _keypress(object: any, listener: EventListener): Handle;
+            export function _keypress(object: any, listener: EventListener): Handle;
             /**
              * `dojo.connect` is a deprecated event handling and delegation method in
              * listeners may be attached to a function, and source functions may
              * be either regular function calls or DOM events.
              */
-                connect(obj: any, event: string, context: any, method: EventListener | string, dontFix?: boolean): Handle;
+            export function connect(obj: any, event: string, context: any, method: EventListener | string, dontFix?: boolean): Handle;
-                connect(event: string, context: any, method: EventListener | string, dontFix?: boolean): Handle;
+            export function connect(event: string, context: any, method: EventListener | string, dontFix?: boolean): Handle;
             /**
              * Remove a link created by dojo.connect.
              */
-                disconnect(handle: Handle): void;
+            export function disconnect(handle: Handle): void;
             /**
              * Attach a listener to a named topic. The listener function is invoked whenever the
              * named topic is published (see: dojo.publish).
              * Returns a handle which is needed to unsubscribe this listener.
              */
-                subscribe(topic: string, context: any, method: EventListener): Handle;
+            export function subscribe(topic: string, context: any, method: EventListener): Handle;
             /**
              * Invoke all listener method subscribed to topic.
              */
-                publish(topic: string, args: any[]): boolean;
+            export function publish(topic: string, args: any[]): boolean;
             /**
              * Ensure that every time obj.event() is called, a message is published
              * dojo.disconnect() to disable subsequent automatic publication on
              * the topic.
              */
-                connectPublisher(topic: string, obj: any, method: string): Handle;
+            export function connectPublisher(topic: string, obj: any, method: string): Handle;
-                connectPublisher(topic: string, method: EventListener): Handle;
+            export function connectPublisher(topic: string, method: EventListener): Handle;
             /**
              * Checks an event for the copy key (meta on Mac, and ctrl anywhere else)
              */
-                isCopyKey(e: Event): boolean;
+            export function isCopyKey(e: Event): boolean;
-            }
  No newline at end of file

src/typings/dojo/_base/declare.d.ts +7 -9

-            declare namespace declare {
+            declare module "./kernel" {
-                /* dojo/_base/declare */
+                interface Dojo {
+                    declare: declare.Declare;
+                    safeMixin: typeof declare.safeMixin;
+                }
+            }
-                /**
+            declare namespace declare {
-                 * dojo/_base/declare() returns a constructor `C`.   `new C()` returns an Object with the following
-                 * methods, in addition to the methods and properties specified via the arguments passed to declare().
-                 */
                 interface DeclareCreatedObject {
                     declaredClass: string;
                     createSubclass<U>(mixins: any, props: U): DeclareConstructor<T & U>;
                 }
-                /**
-                 * Create a feature-rich constructor from compact notation.
-                 */
                 interface Declare {
                     <A, B, C, D>(superClass: [DeclareConstructor<A>, DeclareConstructor<B>, DeclareConstructor<C>, DeclareConstructor<D>]): DeclareConstructor<A & B & C & D>;
                     <A, B, C>(superClass: [DeclareConstructor<A>, DeclareConstructor<B>, DeclareConstructor<C>]): DeclareConstructor<A & B & C>;

src/typings/dojo/_base/event.d.ts +5 -6

             /* dojo/_base/event */
             /**
+             * @module
              * This module defines dojo DOM event API.   Usually you should use dojo/on, and evt.stopPropagation() +
              * evt.preventDefault(), rather than this module.
              */
-            interface EventModule {
             /**
              * normalizes properties on the event object including event
              * bubbling methods, keystroke normalization, and x/y positions
              */
-                fix(evt: Event, sender: Element): Event;
+            export declare function fix(evt: Event, sender: Element): Event;
             /**
              * prevents propagation and clobbers the default action of the
              * passed event
              */
-                stop(evt: Event): void;
+            export declare function stop(evt: Event): void;
-            declare const dojoEvent: EventModule;
-            export = dojoEvent;

src/typings/dojo/_base/fx.d.ts +23 -26

             import Evented = require("../Evented");
-            declare namespace fx {
             /* dojo/_base/fx */
-                interface Line {
+            export interface _Line {
                 /**
                  * Returns the point on the line
                  * @param {number} n a floating point number greater than 0 and less than 1
             /**
              * Object used to generate values from a start value to an end value
              */
-                interface LineConstructor {
+            export interface LineConstructor {
-                    new(start: number, end: number): Line;
+                new(start: number, end: number): _Line;
+                prototype: _Line;
             }
-                interface EasingFunction {
+            export interface EasingFunction {
                 (n?: number): number;
             }
-                interface Animation extends Evented {
+            export interface Animation extends Evented {
                 /**
                  * The time in milliseconds the animation will take to run
                  */
                  * A two element array of start and end values, or a `_Line` instance to be
                  * used in the Animation.
                  */
-                    curve: Line | [number, number];
+                curve: _Line | [number, number];
                 /**
                  * A Function to adjust the acceleration (or deceleration) of the progress
                  */
                 onStop?: Event;
-                    _precent: number;
+                _percent: number;
                 _startRepeatCount: number;
                 _getStep(): number;
              * A generic animation class that fires callbacks into its handlers
              * object at various states.
              */
-                interface AnimationConstructor {
+            export interface AnimationConstructor {
                 new(args: any): Animation;
                 prototype: Animation;
             }
-                interface AnimationCallback {
+            export interface AnimationCallback {
                 (node: HTMLElement): void;
             }
-                interface FadeArguments {
+            export interface FadeArguments {
                 node: HTMLElement | string;
                 duration?: number;
                 easing?: EasingFunction;
                 end?: Function;
             }
-                interface AnimationArgumentsProperties {
+            export interface AnimationArgumentsProperties {
                 [name: string]: any;
             }
-                interface AnimationArguments extends FadeArguments {
+            export interface AnimationArguments extends FadeArguments {
                 properties?: AnimationArgumentsProperties;
                 onEnd?: AnimationCallback;
             }
-                interface Fx {
-                    _Line: LineConstructor;
+            export const _Line: LineConstructor;
-                    Animation: AnimationConstructor;
+            export const Animation: AnimationConstructor;
-                    _fade(args: any): Animation;
+            export function _fade(args: any): Animation;
             /**
              * Returns an animation that will fade node defined in 'args' from
              * its current opacity to fully opaque.
              */
-                    fadeIn(args: FadeArguments): Animation;
+            export function fadeIn(args: FadeArguments): Animation;
             /**
              * Returns an animation that will fade node defined in 'args'
              * from its current opacity to fully transparent.
              */
-                    fadeOut(args: FadeArguments): Animation;
+            export function fadeOut(args: FadeArguments): Animation;
-                    _defaultEasing(n?: number): number;
+            export function _defaultEasing(n?: number): number;
             /**
              * Returns an animation that will transition the properties of
              * node defined in `args` depending how they are defined in
              * `args.properties`
              */
-                    animateProperty(args: AnimationArguments): Animation;
+            export function animateProperty(args: AnimationArguments): Animation;
             /**
              * A simpler interface to `animateProperty()`, also returns
              * an instance of `Animation` but begins the animation
              * immediately, unlike nearly every other Dojo animation API.
              */
-                    anim(
+            export function anim(
                 node: HTMLElement | string,
                 properties: { [name: string]: any },
                 duration?: number,
                 easing?: Function,
                 onEnd?: AnimationCallback,
                 delay?: number): Animation;
-            declare const fx: fx.Fx;
-            export = fx;

src/typings/dojo/_base/kernel.d.ts +1 -2

             /* dojo/_base/kernel */
-            import Config = require('./config');
+            import  { Config } from './config';
             declare namespace dojo {
                 interface Dijit {
                     config: Config;
                     global: any;
-                    // TODO: dojot, dojox
                     dijit: Dijit;
                     dojox: Dojox;

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