Update d3.d.ts

d3.cloud.layout/d3.cloud.layout.d.ts

@@ -5,41 +5,77 @@
 
 /// <reference path="../d3/d3.d.ts" />
 
-declare module D3 {
-  export module Layout {
-    export interface IRotate      { 
-      (number:number) : CloudLayout;
-        (number:()=>number) : CloudLayout;
+declare module d3 {
+    module layout {
+        export function cloud(): Cloud<cloud.Word>;
+        export function cloud<T extends cloud.Word>(): Cloud<T>;
+
+        module cloud {
+            interface Word {
+                text?: string;
+                font?: string;
+                style?: string;
+                weight?: string | number;
+                rotate?: number;
+                size?: number;
+                padding?: number;
+                x?: number;
+                y?: number;
+            }
         }
 
+        interface Cloud<T extends cloud.Word> {
+            start(): Cloud<T>;
+            stop(): Cloud<T>;
 
+            timeInterval(): number;
+            timeInterval(interval: number): Cloud<T>;
 
-    export interface CloudLayout {
-      (layers: any[], index?: number): any[];
-      values(accessor?: (d: any) => any): CloudLayout;
-      offset(offset: string): CloudLayout;
-      size: {
-        /**
-      * Gets the available layout size 
-      */
-        (): Array<number>;
-        /**
-      * Sets the available layout size 
-      */
-        (size: Array<number>): CloudLayout;
-      };
-      words: (inputArray: Array<any>) => CloudLayout;
-      rotate:IRotate;
-      padding: (number:number) => CloudLayout;
-      font: (string:string) => CloudLayout;
-      fontSize(fctn: (d: any) => number): CloudLayout;
-      on: (eventname: string, callee: (words: any[]) => void) => CloudLayout;
-      start: () => CloudLayout;
+            words(): T[];
+            words(words: T[]): Cloud<T>;
+
+            size(): [number, number];
+            size(size: [number, number]): Cloud<T>;
+
+            font(): (datum: T, index: number) => string;
+            font(font: string): Cloud<T>;
+            font(font: (datum: T, index: number) => string): Cloud<T>;
+
+            fontStyle(): (datum: T, index: number) => string;
+            fontStyle(style: string): Cloud<T>;
+            fontStyle(style: (datum: T, index: number) => string): Cloud<T>;
+
+            fontWeight(): (datum: T, index: number) => string | number;
+            fontWeight(weight: string | number): Cloud<T>;
+            fontWeight(weight: (datum: T, index: number) => string | number): Cloud<T>;
+
+            rotate(): (datum: T, index: number) => number;
+            rotate(rotate: number): Cloud<T>;
+            rotate(rotate: (datum: T, index: number) => number): Cloud<T>;
+
+            text(): (datum: T, index: number) => string;
+            text(text: string): Cloud<T>;
+            text(text: (datum: T, index: number) => string): Cloud<T>;
+
+            spiral(): (size: number) => (t: number) => [number, number];
+            spiral(name: string): Cloud<T>;
+            spiral(spiral: (size: number) => (t: number) => [number, number]): Cloud<T>;
+
+            fontSize(): (datum: T, index: number) => number;
+            fontSize(size: number): Cloud<T>;
+            fontSize(size: (datum: T, index: number) => number): Cloud<T>;
+
+            padding(): (datum: T, index: number) => number;
+            padding(padding: number): Cloud<T>;
+            padding(padding: (datum: T, index: number) => number): Cloud<T>;
+
+            on(type: "word", listener: (word: T) => void): Cloud<T>;
+            on(type: "end", listener: (tags: T[], bounds: { x: number; y: number }[]) => void): Cloud<T>;
+            on(type: string, listener: (...args: any[]) => void): Cloud<T>;
+
+            on(type: "word"): (word: T) => void;
+            on(type: "end"): (tags: T[], bounds: { x: number; y: number }[]) => void;
+            on(type: string): (...args: any[]) => void;
+        }
     }
-
-
-    export interface Layout {
-      cloud(): CloudLayout; 
-    }
-  }
-}
+}

d3/plugins/d3.superformula-tests.ts

@@ -12,7 +12,7 @@ function superformula() {
         .attr("width", 960)
         .attr("height", 500);
 
-    var small = d3.superformula()
+    var small = d3.superformula<string>()
         .type(function (d) { return d; } )
         .size(size);
 
@@ -37,4 +37,4 @@ function superformula() {
         .attr("class", "big")
         .attr("transform", "translate(450,250)")
         .attr("d", big);
-}
+}

d3/plugins/d3.superformula.d.ts

@@ -1,38 +1,37 @@
 /// <reference path="../d3.d.ts" />
 
+declare module d3 {
+    export function superformula<T>(): Superformula<T>;
 
-declare module D3 {
-    interface SuperformulaPath
-    {
-        superformulaPath(params: number[], n: number, diameter: number): Superformula;
+    module superformula {
+        interface Type {
+            m: number;
+            n1: number;
+            n2: number;
+            n3: number;
+            a: number;
+            b: number;
+        }
     }
 
+    interface Superformula<T> {
+        (datum: T, index: number): string;
 
-    interface SuperformulaType
-    {
-        (any: any): any;//hans
-        m: number;
-        n1: number;
-        n2: number;
-        n3: number;
-        a: number;
-        b: number;
+        type(): (datum: T, index: number) => string;
+        type(type: string): Superformula<T>;
+        type(type: (datum: T, index: number) => string): Superformula<T>;
+
+        size(): (datum: T, index: number) => number;
+        size(size: number): Superformula<T>;
+        size(size: (datum: T, index: number) => number): Superformula<T>;
+
+        segments(): (datum: T, index: number) => number;
+        segments(segments: number): Superformula<T>;
+        segments(segments: (datum: T, index: number) => number): Superformula<T>;
+
+        param(name: string): number;
+        param(name: string, value: number): Superformula<T>;
     }
 
-    interface Superformula
-    {
-        (): any;
-        type(any: any): any;
-        param(name: string, value: number): Superformula;
-        size(x: number): Superformula;
-        segments(x: number): Superformula;
-    }
-
-
-    interface Base extends Selectors
-    {
-        superformula: Superformula;
-        superformulaPath: SuperformulaPath;
-        superformulaTypes: SuperformulaType[];
-    }
+    export var superformulaTypes: string[];
 }