这篇教程介绍了如何在Eclipse中安装和使用TypeScript，TypeScript是JavaScript的超集，增加了静态类型和面向对象编程特性。文章涵盖了语言的背景、特性，包括类型批注、类、接口和模块，并提及了对ECMAScript 6的支持。
TypeScript是一种由微软开发的自由和开源的编程语言。它是JavaScript的一个超集，而且本质上向这个语言添加了可选的静态类型和基于类的面向对象编程。安德斯·海尔斯伯格，C#的首席架构师，已工作于TypeScript的开发。2012年十月份，微软发布了首个公开版本的TypeScript，2013年6月19日，在经历了一个预览版之后微软正式发布了正式版TypeScript 0.9，向未来的TypeScript 1.0版迈进了很大一步。
简介
编辑
TypeScript是一种由微软开发的自由和开源的编程语言。它是JavaScript的一个超集，而且本质上向这个语言添加了可选的静态类型和基于类的面向对象编程。安德斯·海尔斯伯格，C#的首席架构师，已工作于TypeScript的开发。[1-4]
TypeScript扩展了 JavaScript 的句法，所以任何现有的JavaScript程序可以不加改变的在TypeScript下工作。TypeScript是为大型应用之开发而设计，而编译时它产生 JavaScript 以确保兼容性。[5]
TypeScript 支持为已存在的 JavaScript 库添加类型信息的头文件，扩展了它对于流行的库如 jQuery，MongoDB，Node.js 和 D3.js 的好处。
2背景
TypeScript 起源于开发应用程序规模的 JavaScript 应用程序的需求。Microsoft 的语言开发者们说内部以及外部的客户都表示他们构建 JavaScript 代码的问题。
很多最终依赖于 JavaScript 的开发者通常用编译为 JavaScript 代码的另一种语言写脚本，例如 CoffeeScript 和 Script# (读作 ScriptSharp)。一个明显的劣势是也许无法从那另一种语言使用任何 JavaScript 的具体的语言特性，如果那种语言不支持它的话。
在 Microsoft 内部，它导致了自定义工具以简化 JavaScript 组件的编写的需求。
3特性
TypeScript 是一种给 JavaScript 添加特性的语言扩展。
● 类型批注和编译时类型检查
●类
●接口
●模块 [6]
●lambda 函数
语法上，TypeScript 很类似于 JScript .NET，另外一个添加了对静态类型，经典的面向对象语言特性如类，继承，接口和命名空间等的支持的 Microsoft 对 ECMA-262 语言标准的实现。
类型批注
TypeScript 通过类型批注提供静态类型以在编译时启动类型检查。这是可选的，而且可以被忽略而使用 JavaScript 常规的动态类型。
对于基本类型的批注是 number, bool 和 string。而弱或动态类型的结构则是 any 类型。
类型批注可以被导出到一个单独的声明文件以让使用类型的已被编译为 JavaScript 的 TypeScript 脚本的类型信息可用。批注可以为一个现有的 JavaScript 库声明，就像已经为 Node.js 和 jQuery 所做的那样。
当类型没有给出时，TypeScript 编译器利用类型推断以推断类型。如果由于缺乏声明，没有类型可以被推断出，那么它就会默认为是动态的 any 类型。
声明文件
当一个 TypeScript 脚本被编译时，有一个产生作为编译后的 JavaScript 的组件的一个接口而起作用的声明文件 (具有扩展名 .d.ts) 的选项。在这个过程中编译器基本上带走所有的函数和方法体而仅保留所导出类型的批注。当第三方开发者从 TypeScript 中使用它时，由此产生的声明文件就可以被用于描述一个 JavaScript 库或模块导出的虚拟的 TypeScript 类型。
声明文件的概念类似于 C/C++ 中头文件的概念。
类型声明文件可以为已存在的 JavaScript 库手写，就像为 jQuery 和 Node.js 所做的那样。
对 ECMAScript 6 的支持
TypeScript 增加了对为即将到来的 ECMAScript 6 标准所建议的特性的支持。
如下为其构想:
类 (以及继承) 模块Arrow functions
尽管标准还未准备就绪，Microsoft 说它的目标是使 TypeScript 的特性与建议的标准看齐。
类
TypeScript 支持集成了可选的类型批注支持的 ECMAScript 6 的类。
泛型
这种语言的规范说明一个未来的版本将会支持基于类型擦除的泛型编程。
与 JavaScript 的兼容性
TypeScript 是 JavaScript 的一个超集。默认情况下编译器以 ECMAScript 3 (ES3) 为目标但 ES5 也是受支持的一个选项。一个 TypeScript 应用可以利用已存在的 JavaScript 脚本。编译后的 TypeScript 脚本也可以从 JavaScript 中使用。
现有框架如 jQuery 和 Node.js 等受到完全支持。这些库的类型声明在源代码中提供。
支持的浏览器和平台
运行于任何平台上的任何网页浏览器都可以运行 TypeScript 由于它仅仅是被编译为标准的 JavaScript。一个脚本既可以被预编译为 JavaScript 也可以通过为 TypeScript 包含 JavaScript 编译器实时编译。
4工具
TypeScript 编译器，名称叫 tsc, 是用可以被编译为可以被执行在任何 JavaScript 引擎中，在任何宿主 - 如浏览器 - 中的常规 JavaScript 的 TypeScript 写的。编译器包被绑定于一个可以执行编译器的脚本宿主。使用 Node.js 作为宿主的 Node.js 包同样可以获得。
也有用 JavaScript 写的客户端编译器的一个 alpha 版本，它在页面载入时，实时执行 JavaScript 代码。[7]
这种编译器的当前版本默认支持 ECMAScript 3。一个选项是允许以 ECMAScript 5 为目标以利用该版本独有的语言特性。类，尽管是 ECMAScript 6 标准的一部分，在这两个模式下都可用。
IDE 和编辑器支持
Microsoft为 Visual Studio 2012 和 WebMatrix 提供了一个插件，也为 Sublime Text, Emacs 和 Vim 提供了基本的文本编辑器支持。[8] 在线的 Cloud9 IDE也支持 TypeScript。JetBrains 也计划在他们的 IDE 系列中支持 TypeScript, 而且已经发行了具有部分支持的 PhpStorm 6 和 WebStorm 6 预览版本。[9]
5开源
TypeScript 是开源的，其源代码可以在 Apache 2 License 下从 CodePlex 获得。这个项目由 Microsoft 维持，但是任何人可以通过经 CodePlex 项目页发送反馈，建议和 bugfixes 而做出贡献。[10]
已有一些批评提到这一想法，即使 TypeScript 鼓励强类型，当前也只有 Microsoft Visual Studio 允许为该语言容易的开发。最初的观点是在其它的编辑器上带来强类型，IntelliSense, 代码完成和代码重构可能不是一个简单的任务。[11] 此外，允许为 TypeScript 开发的 Visual Studio 扩展不是开源的。最好的 TypeScript 开发体验是在 Microsoft Windows 上，[12] 然而随着时间的流逝以及这种语言开放的本质，加之编译器自我托管，而且用 TypeScript 自身写的，这很有可能会改变。可以通过编译器的源代码访问到 AST (抽象句法树)，也可以获得详细的语言规范文档，社区已开始构建一个跨平台的编辑器，[13-14] 利用和 Visual Studio 所用相同的语言服务以提供一个增强的编辑体验。编辑器仍然在概念检验的阶段，但已经运行于 Linux, OSX 和 Windows，提供针对之前对提供此类服务的困难度的估计的 IntelliSense, 代码完成和句法高亮。
6发布
2013年6月19日，在经历了一个预览版之后微软正式发布了正式版TypeScript 0.9，向未来的TypeScript 1.0版迈进了很大一步。
TypeScript 0.9迎来了一些重大的新功能，除对语言本身特性进行了扩充之外，还更加完善地整合了Visual Studio，微软开发部副总裁Soma Somasegar发布帖子称，新版本的TypeScript在交互式性能方面有了戏剧性的提高和改善。
与JavaScript相比，TypeScript进步的地方包括：加入注释，让编译器理解所支持的对象和函数，编译器会移除注释，不会增加开销；增加一个完整的类结构，使之更新是传统的面向对象语言。[15]
===================================================================================================================================
1)步骤--window -->>NetWork Conntions->
2）打开QQ IP代理找一个网速快的IP设置，建议使用美国的..
http://eclipse-update.palantir.com/eclipse-typescript/
三、注意
1）不要勾选Enable typeScript Builder，勾选了这个它不会帮你生成js文件
2)勾选Disable typeScript Builder即可
四、官方
http://www.typescriptlang.org/(官方网址)
http://www.typescriptlang.org/Tutorial/（官方例子）
五、推荐学习博客
http://blog.oio.de/2013/08/05/typescript-plug-in-for-eclipse/（安装博客）
http://freewind.me/blog/20130128/2034.html（学习博客）
六、Nodejs下载
http://nodejs.org/download/
七、插件下载
http://www.oschina.net/question/12_72250
八、图解
class Greeter{
element:HTMLElement;
span:HTMLElement;
timerToken:number;
constructor(element:HTMLElement){
this.element=element;
this.element.innerText+="this time is: ";
this.span=document.createElement("span");
this.element.appendChild(this.span);
this.span.innerText=new Date().toUTCString();
}
//start
start(){
this.timerToken=setInterval(()=>
this.span.innerText=new Date().toUTCString(),500
);
}
//stop
stop(){
clearTimeout(this.timerToken);
}
}
window.οnlοad= ()=>{
var el=document.getElementById("content");
var greeter=new Greeter(el);//create greeter object
greeter.start();
}
// Type definitions for Kendo UI
declare module kendo {
function bind(selector: string, viewModel: any, namespace?: any): void;
function bind(element: JQuery, viewModel: any, namespace?: any): void;
function bind(element: Element, viewModel: any, namespace?: any): void;
function culture(value: string): void;
function culture(): {
name: string;
calendar: {
AM: string[];
PM: string[];
days: {
names: string[];
namesAbbr: string[];
namesShort: string[];
firstDay: number;
};
months: {
names: string[];
namesAbbr: string[];
};
patterns: {
D: string;
F: string;
G: string;
M: string;
T: string;
Y: string;
d: string;
g: string;
m: string;
s: string;
t: string;
u: string;
y: string;
};
twoDigitYearMax: number;
};
calendars: {
standard: {
AM: string[];
PM: string[];
days: {
names: string[];
namesAbbr: string[];
namesShort: string[];
firstDay: number;
};
months: {
names: string[];
namesAbbr: string[];
};
patterns: {
D: string;
F: string;
G: string;
M: string;
T: string;
Y: string;
d: string;
g: string;
m: string;
s: string;
t: string;
u: string;
y: string;
};
twoDigitYearMax: number;
};
};
numberFormat: {
currency: {
decimals: number;
groupSize: number[];
pattern: string[];
symbol: string;
};
decimals: number;
groupSize: number[];
pattern: string[];
percent: {
decimals: number;
groupSize: number[];
pattern: string[];
symbol: string;
};
};
};
function destroy(selector: string): void;
function destroy(element: Element): void;
function destroy(element: JQuery): void;
function format(format: string, ...values: any[]): string;
function fx(selector: string): effects.Element;
function fx(element: Element): effects.Element;
function fx(element: JQuery): effects.Element;
function htmlEncode(value: string): string;
function init(selector: string, ...namespaces: any[]): void;
function init(element: JQuery, ...namespaces: any[]): void;
function init(element: Element, ...namespaces: any[]): void;
function observable(data: any): kendo.data.ObservableObject;
function observableHierarchy(array: any[]): kendo.data.ObservableArray;
function parseDate(value: any, format?: string, culture?: string): Date;
function parseFloat(value: any, culture?: string): number;
function parseInt(value: any, culture?: string): number;
function render(template:(data: any) => string, data: any[]): string;
function stringify(value: Object): string;
function template(template: string, options?: TemplateOptions): (data: any) => string;
function touchScroller(selector: string): void;
function touchScroller(element: Element): void;
function touchScroller(element: JQuery): void;
function toString(value: number, format: string): string;
function toString(value: Date, format: string): string;
function unbind(selector: string): void;
function unbind(element: JQuery): void;
function unbind(element: Element): void;
function guid(): string;
var ns: string;
var keys: {
INSERT: number;
DELETE: number;
BACKSPACE: number;
TAB: number;
ENTER: number;
ESC: number;
LEFT: number;
UP: number;
RIGHT: number;
DOWN: number;
END: number;
HOME: number;
SPACEBAR: number;
PAGEUP: number;
PAGEDOWN: number;
F2: number;
F10: number;
F12: number;
}
var support: {
touch: bool;
pointers: bool;
scrollbar(): number;
hasHW3D: bool;
hasNativeScrolling: bool;
devicePixelRatio: number;
placeHolder: bool;
zoomLevel: number;
mobileOS: {
device: string;
tablet: any;
browser: string;
name: string;
majorVersion: string;
minorVersion: string;
flatVersion: number;
appMode: bool;
};
browser: {
msie: bool;
webkit: bool;
safari: bool;
opera: bool;
version: string;
};
}
interface TemplateOptions {
paramName?: string;
useWithBlock?: bool;
}
class Class {
static fn: Class;
static extend(prototype: Object): Class;
}
class Observable extends Class {
static fn: Observable;
static extend(prototype: Object): Observable;
bind(eventName: string, handler: Function): Observable;
one(eventName: string, handler: Function): Observable;
trigger(eventName: string, e?: any): bool;
unbind(eventName: string, handler?: any): Observable;
}
interface ViewOptions {
tagName?: string;
wrap?: bool;
model?: Object;
init?: (e: ViewEvent) => void;
show?: (e: ViewEvent) => void;
hide?: (e: ViewEvent) => void;
}
interface ViewEvent {
sender: View;
isDefaultPrevented(): bool;
preventDefault: Function;
}
class View extends Observable {
constructor(element: Element, options?: ViewOptions);
constructor(element: string, options?: ViewOptions);
init(element: Element, options?: ViewOptions): void;
init(element: string, options?: ViewOptions): void;
render(container?: any): JQuery;
destroy(): void;
element: JQuery;
content: any;
tagName: string;
model: Object;
}
class Layout extends View {
showIn(selector: string, view: View);
regions: { [selector: string]: View; };
}
class History extends Observable {
start(options): void;
stop(): void;
current: string;
root: string;
change(callback): void;
navigate(location: string, silent?: bool);
}
var history: History;
interface RouterOptions {
init?: (e: RouterEvent) => void;
routeMissing?: (e: RouterEvent) => void;
change?: (e: RouterEvent) => void;
}
interface RouterEvent {
sender: Router;
isDefaultPrevented(): bool;
preventDefault: Function;
url: string;
}
class Route extends Class {
route: RegExp;
callback(url: string): void;
worksWith(url: string): void;
}
class Router extends Observable {
constructor(options?: RouterOptions);
init(options?: RouterOptions): void;
start(): void;
destroy(): void;
route(route: string, callback: Function): void;
navigate(location: string, silent?: bool);
routes: Route[];
}
}
declare module kendo.effects {
interface Element {
expand(direction: string): effects.Expand;
expandHorizontal(): effects.Expand;
expandVertical(): effects.Expand;
fade(direction: string): effects.Fade;
fadeIn(): effects.Fade;
fadeOut(): effects.Fade;
flip(axis: string, face: JQuery, back: JQuery): effects.Flip;
flipHorizontal(face: JQuery, back: JQuery): effects.Flip;
flipVertical(face: JQuery, back: JQuery): effects.Flip;
pageturn(axis: string, face: JQuery, back: JQuery): effects.PageTurn;
pageturnHorizontal(face: JQuery, back: JQuery): effects.PageTurn;
pageturnVertical(face: JQuery, back: JQuery): effects.PageTurn;
slideIn(direction: string): effects.SlideIn;
slideInDown(): effects.SlideIn;
slideInLeft(): effects.SlideIn;
slideInRight(): effects.SlideIn;
slideInUp(): effects.SlideIn;
tile(direction: string, previous: JQuery): effects.Tile;
tileDown(previous: JQuery): effects.Tile;
tileLeft(previous: JQuery): effects.Tile;
tileRight(previous: JQuery): effects.Tile;
tileUp(previous: JQuery): effects.Tile;
transfer(target: JQuery): effects.Transfer;
zoom(direction: string): effects.Zoom;
zoomIn(): effects.Zoom;
zoomOut(): effects.Zoom;
}
interface Effect {
play(): JQueryPromise;
reverse(): JQueryPromise;
duration(value: number): Effect;
add(effect: Effect): Effect;
stop(): Effect;
}
interface Expand extends Effect {
duration(value: number): Expand;
direction(value: string): Expand;
stop(): Expand;
add(effect: Effect): Expand;
}
interface Fade extends Effect {
duration(value: number): Fade;
direction(value: string): Fade;
stop(): Fade;
add(effect: Effect): Fade;
startValue(value: number): Fade;
endValue(value: number): Fade;
}
interface Flip extends Effect {
duration(value: number): Flip;
direction(value: string): Flip;
stop(): Flip;
add(effect: Effect): Flip;
}
interface PageTurn extends Effect {
duration(value: number): PageTurn;
direction(value: string): PageTurn;
stop(): PageTurn;
add(effect: Effect): PageTurn;
}
interface SlideIn extends Effect {
duration(value: number): SlideIn;
direction(value: string): SlideIn;
stop(): SlideIn;
add(effect: Effect): SlideIn;
}
interface Tile extends Effect {
duration(value: number): Tile;
direction(value: string): Tile;
stop(): Tile;
add(effect: Effect): Tile;
}
interface Transfer extends Effect {
duration(value: number): Transfer;
stop(): Transfer;
add(effect: Effect): Transfer;
}
interface Zoom extends Effect {
duration(value: number): Zoom;
direction(value: string): Zoom;
stop(): Zoom;
add(effect: Effect): Zoom;
startValue(value: number): Zoom;
endValue(value: number): Zoom;
}
}
declare module kendo.data {
interface ObservableObjectEvent {
sender?: ObservableObject;
field?: string;
}
interface ObservableObjectSetEvent extends ObservableObjectEvent {
value?: any;
preventDefault?: Function;
}
class Binding extends Observable {
source: any;
parents: any[];
path: string;
dependencies: { [path: string]: bool; };
observable: bool;
constructor(parents: any[], path: string);
change(e): void;
start(source): void;
stop(source): void;
get (): any;
set (value: any): void;
destroy(): void;
}
class EventBinding extends Binding {
get (): void;
}
class TemplateBinding extends Binding {
constructor(source, path, template);
render(value): string;
}
module binders { };
class Binder extends Class {
static fn: Binder;
static extend(prototype: Object): Binder;
element: any;
bindings: { [key: string]: Binding; };
constructor(element: any, bindings: { [key: string]: Binding; }, options?: BinderOptions);
init(element: any, bindings: { [key: string]: Binding; }, options?: BinderOptions): void;
bind(binding: Binding, attribute: string);
destroy(): void;
refresh(): void;
refresh(attribute: string): void;
options: BinderOptions;
}
interface BinderOptions {
}
class ObservableObject extends Observable{
constructor(value?: any);
init(value?: any): void;
get(name: string): any;
parent(): ObservableObject;
set(name: string, value: any): void;
toJSON(): { [key: string]: any; };
uid: string;
}
class Model extends ObservableObject {
idField: string;
_defaultId: any;
fields: DataSourceSchemaModelFields;
defaults: any;
constructor(data?: any);
init(data?: any):void;
dirty: bool;
id: any;
editable(field: string): bool;
isNew(): bool;
static idField: string;
static fields: DataSourceSchemaModelFields;
static define(options: DataSourceSchemaModelWithFieldsObject): {
idField: string;
fields: DataSourceSchemaModelFields;
new (data?: any): Model;
};
static define(options: DataSourceSchemaModelWithFieldsArray): {
idField: string;
fields: DataSourceSchemaModelFields;
new (data?: any): Model;
};
}
class SchedulerEvent extends Model {
constructor(data?: any);
init(data?: any): void;
description: string;
end: Date;
endTimezone: string;
isAllDay: bool;
id: any;
start: Date;
startTimezone: string;
recurrenceId: any;
recurrenceRule: string;
recurrenceException: string;
static define(options: DataSourceSchemaModelWithFieldsObject): {
idField: string;
fields: DataSourceSchemaModelFields;
new (data?: any): SchedulerEvent;
};
static define(options: DataSourceSchemaModelWithFieldsArray): {
idField: string;
fields: DataSourceSchemaModelFields;
new (data?: any): SchedulerEvent;
};
}
class Node extends Model {
children: HierarchicalDataSource;
append(model: any): void;
level(): number;
load(id: any): void;
loaded(value: bool): void;
loaded(): bool;
parentNode(): Node;
}
class SchedulerDataSource extends DataSource {
add(model: Object): kendo.data.SchedulerEvent;
add(model: kendo.data.SchedulerEvent): kendo.data.SchedulerEvent;
at(index: number): kendo.data.SchedulerEvent;
cancelChanges(model?: kendo.data.SchedulerEvent): void;
get(id: any): kendo.data.SchedulerEvent;
getByUid(uid: string): kendo.data.SchedulerEvent;
indexOf(value: kendo.data.SchedulerEvent): number;
insert(index: number, model: kendo.data.SchedulerEvent): kendo.data.SchedulerEvent;
insert(index: number, model: Object): kendo.data.SchedulerEvent;
remove(model: kendo.data.SchedulerEvent): void;
}
class HierarchicalDataSource extends DataSource {
constructor(options?: HierarchicalDataSourceOptions);
init(options?: HierarchicalDataSourceOptions): void;
}
interface HierarchicalDataSourceOptions extends DataSourceOptions {
schema?: HierarchicalDataSourceSchema;
}
interface HierarchicalDataSourceSchema extends DataSourceSchemaWithOptionsModel {
model?: HierarchicalDataSourceSchemaModel;
}
interface HierarchicalDataSourceSchemaModel extends DataSourceSchemaModel {
hasChildren?: any;
children?: any;
}
interface DataSourceTransport {
parameterMap?(data: DataSourceTransportParameterMapData, type: string): any;
}
interface DataSourceParameterMapDataAggregate {
field?: string;
aggregate?: string;
}
interface DataSourceParameterMapDataGroup {
aggregate?: DataSourceParameterMapDataAggregate[];
field?: string;
dir?: string;
}
interface DataSourceParameterMapDataFilter {
field?: string;
filters?: DataSourceParameterMapDataFilter[];
logic?: string;
operator?: string;
value?: any;
}
interface DataSourceParameterMapDataSort {
field?: string;
dir?: string;
}
interface DataSourceTransportParameterMapData {
aggregate?: DataSourceParameterMapDataAggregate[];
group?: DataSourceParameterMapDataGroup[];
filter?: DataSourceParameterMapDataFilter;
models?: Model[];
page?: number;
pageSize?: number;
skip?: number;
sort?: DataSourceParameterMapDataSort[];
take?: number;
}
interface DataSourceSchema {
model?: any;
}
interface DataSourceSchemaWithOptionsModel extends DataSourceSchema {
model?: DataSourceSchemaModel;
}
interface DataSourceSchemaWithConstructorModel extends DataSourceSchema {
model?: {
idField: string;
fields: DataSourceSchemaModelFields;
new (data?: any): Model;
};
}
interface DataSourceSchemaModel {
id?: string;
fields?: any;
}
interface DataSourceSchemaModelWithFieldsArray extends DataSourceSchemaModel {
fields?: DataSourceSchemaModelField[];
}
interface DataSourceSchemaModelWithFieldsObject extends DataSourceSchemaModel {
fields?: DataSourceSchemaModelFields;
}
interface DataSourceSchemaModelFields {
[index: string]: DataSourceSchemaModelField;
}
interface DataSourceSchemaModelField {
field?: string;
from?: string;
defaultValue?: any;
editable?: bool;
nullable?: bool;
parse?: Function;
type?: string;
validation?: DataSourceSchemaModelFieldValidation;
}
interface DataSourceSchemaModelFieldValidation {
required?: bool;
min?: any;
max?: any;
}
class ObservableArray extends Observable {
constructor(array?: any[]);
init(array?: any[]): void;
length: number;
join(separator: string): string;
parent(): ObservableObject;
pop(): ObservableObject;
push(...items: any[]): number;
slice(begin: number, end?: number): any[];
splice(start: number): any[];
splice(start: number, deleteCount: number, ...items: any[]): any[];
shift(): any;
toJSON(): any[];
unshift(...items: any[]): number;
wrapAll(source, target): any;
wrap(object, parent): any;
indexOf(item: any): number;
forEach(callback: (item, index: number, source: ObservableArray) => void ): void;
map(callback: (item, index: number, source: ObservableArray) => any): any[];
filter(callback: (item, index: number, source: ObservableArray) => bool): any[];
find(callback: (item, index: number, source: ObservableArray) => bool): any;
every(callback: (item, index: number, source: ObservableArray) => bool): bool;
some(callback: (item, index: number, source: ObservableArray) => bool): bool;
remove(item): void;
}
interface ObservableArrayEvent {
field?: string;
action?: string;
index?: number;
items?: kendo.data.Model[];
}
class DataSource extends Observable{
constructor(options?: DataSourceOptions);
init(options?: DataSourceOptions): void;
static create(options?: DataSourceOptions): DataSource;
options: DataSourceOptions;
add(model: Object): kendo.data.Model;
add(model: kendo.data.Model): kendo.data.Model;
aggregate(val: any): void;
aggregate(): any;
aggregates(): any;
at(index: number): kendo.data.ObservableObject;
cancelChanges(model?: kendo.data.Model): void;
data(): kendo.data.ObservableArray;
data(value: any): void;
fetch(callback?: Function): void;
filter(filters: DataSourceFilterItem): void;
filter(filters: DataSourceFilterItem[]): void;
filter(filters: DataSourceFilters): void;
filter(): DataSourceFilters;
get(id: any): kendo.data.Model;
getByUid(uid: string): kendo.data.Model;
group(groups: any): void;
group(): any;
hasChanges(): bool;
indexOf(value: kendo.data.ObservableObject): number;
insert(index: number, model: kendo.data.Model): kendo.data.Model;
insert(index: number, model: Object): kendo.data.Model;
page(): number;
page(page: number): void;
pageSize(): number;
pageSize(size: number): void;
query(options?: any): void;
read(data?: any): void;
remove(model: kendo.data.Model): void;
sort(sort: DataSourceSortItem): void;
sort(sort: DataSourceSortItem[]): void;
sort(): DataSourceSortItem[];
sync(): void;
total(): number;
totalPages(): number;
view(): kendo.data.ObservableArray;
}
interface DataSourceAggregateItem {
field?: string;
aggregate?: string;
}
interface DataSourceFilter {
}
interface DataSourceFilterItem extends DataSourceFilter {
operator?: string;
field?: string;
value?: any;
}
interface DataSourceFilters extends DataSourceFilter {
logic?: string;
filters?: DataSourceFilter[];
}
interface DataSourceGroupItemAggregate {
field?: string;
aggregate?: string;
}
interface DataSourceGroupItem {
field?: string;
dir?: string;
aggregates?: DataSourceGroupItemAggregate[];
}
interface DataSourceSchema {
aggregates?: any;
data?: any;
errors?: any;
groups?: any;
parse?: Function;
total?: any;
type?: string;
}
interface DataSourceSortItem {
field?: string;
dir?: string;
}
interface DataSourceTransportCreate {
cache?: bool;
contentType?: string;
data?: any;
dataType?: string;
type?: string;
url?: any;
}
interface DataSourceTransportDestroy {
cache?: bool;
contentType?: string;
data?: any;
dataType?: string;
type?: string;
url?: any;
}
interface DataSourceTransportRead {
cache?: bool;
contentType?: string;
data?: any;
dataType?: string;
type?: string;
url?: any;
}
interface DataSourceTransportUpdate {
cache?: bool;
contentType?: string;
data?: any;
dataType?: string;
type?: string;
url?: any;
}
interface DataSourceTransport {
create?: any;
destroy?: any;
read?: any;
update?: any;
}
interface DataSourceTransportWithObjectOperations extends DataSourceTransport {
create?: DataSourceTransportCreate;
destroy?: DataSourceTransportDestroy;
read?: DataSourceTransportRead;
update?: DataSourceTransportUpdate;
}
interface DataSourceTransportWithFunctionOperations extends DataSourceTransport {
create?: (options: DataSourceTransportOptions) => void;
destroy?: (options: DataSourceTransportOptions) => void;
read?: (options: DataSourceTransportReadOptions) => void;
update?: (options: DataSourceTransportOptions) => void;
}
interface DataSourceTransportOptions {
success: (data?: any) => void;
error: (error?: any) => void;
data: any;
}
interface DataSourceTransportReadOptionsData {
sort?: DataSourceSortItem[];
filter?: DataSourceFilters;
take?: number;
skip?: number;
}
interface DataSourceTransportReadOptions extends DataSourceTransportOptions {
data: DataSourceTransportReadOptionsData;
}
interface DataSourceTransportBatchOptionsData {
models: any[];
}
interface DataSourceTransportBatchOptions extends DataSourceTransportOptions {
data: DataSourceTransportBatchOptionsData;
}
interface DataSourceOptions {
aggregate?: DataSourceAggregateItem[];
autoSync?: bool;
batch?: bool;
data?: any;
filter?: any;
group?: DataSourceGroupItem[];
page?: number;
pageSize?: number;
schema?: DataSourceSchema;
serverAggregates?: bool;
serverFiltering?: bool;
serverGrouping?: bool;
serverPaging?: bool;
serverSorting?: bool;
sort?: any;
transport?: DataSourceTransport;
type?: string;
change? (e: DataSourceChangeEvent): void;
error?(e: DataSourceErrorEvent): void;
sync?(e: DataSourceEvent): void;
requestStart?(e: DataSourceRequestStartEvent): void;
requestEnd?(e: DataSourceRequestEndEvent): void;
}
interface DataSourceEvent {
sender?: DataSource;
}
interface DataSourceItemOrGroup {
}
interface DataSourceGroup extends DataSourceItemOrGroup {
aggregates: any[];
field: string;
hasSubgroups: bool;
items: DataSourceItemOrGroup[];
value: any;
}
interface DataSourceChangeEvent extends DataSourceEvent {
field?: string;
value?: Model;
action?: string;
index?: number;
items?: DataSourceItemOrGroup[];
node?: any;
}
interface DataSourceErrorEvent extends DataSourceEvent {
xhr: JQueryXHR;
status: string;
errorThrown: any;
errors?: any;
}
interface DataSourceRequestStartEvent extends DataSourceEvent {
}
interface DataSourceRequestEndEvent extends DataSourceEvent {
response?: any;
type?: string;
}
}
declare module kendo.data.transports {
var odata : DataSourceTransport;
}
declare module kendo.ui {
function progress(container: JQuery, toggle: bool);
class Widget extends Observable {
static fn: Widget;
static extend(prototype: Object): Widget;
constructor(element: Element, options?: any);
constructor(element: JQuery, options?: any);
constructor(selector: String, options?: any);
init(element: Element, options?: any): void;
init(element: JQuery, options?: any): void;
init(selector: String, options: Object): void;
destroy(): void;
element: JQuery;
setOptions(options: Object): void;
}
function plugin(widget: kendo.ui.Widget, register?: Object, prefix?: String);
function plugin(widget: any, register?: Object, prefix?: String);
function plugin(widget: new (element: Element, options: Object) => kendo.ui.Widget, register?: Object, prefix?: String);
class Draggable extends kendo.ui.Widget{
element: JQuery;
currentTarget: JQuery;
constructor(element: Element, options?: DraggableOptions);
options: DraggableOptions;
}
interface DraggableEvent extends JQueryEventObject {
sender?: Draggable;
}
class DropTarget extends kendo.ui.Widget{
element: JQuery;
constructor(element: Element, options?: DropTargetOptions);
options: DropTargetOptions;
destroyGroup(): void;
}
interface DropTargetOptions {
group?: string;
dragenter?(e: DropTargetDragenterEvent): void;
dragleave?(e: DropTargetDragleaveEvent): void;
drop?(e: DropTargetDropEvent): void;
}
interface DropTargetEvent extends JQueryEventObject {
sender?: DropTarget;
}
interface DropTargetDragenterEvent extends DropTargetEvent {
draggable?: kendo.ui.Draggable;
}
interface DropTargetDragleaveEvent extends DropTargetEvent {
draggable?: kendo.ui.Draggable;
}
interface DropTargetDropEvent extends DropTargetEvent {
draggable?: kendo.ui.Draggable;
}
class DropTargetArea extends kendo.ui.Widget{
element: JQuery;
constructor(element: Element, options?: DropTargetAreaOptions);
options: DropTargetAreaOptions;
}
interface DropTargetAreaOptions {
group?: string;
filter?: string;
dragenter?(e: DropTargetAreaDragenterEvent): void;
dragleave?(e: DropTargetAreaDragleaveEvent): void;
drop?(e: DropTargetAreaDropEvent): void;
}
interface DropTargetAreaEvent extends JQueryEventObject {
sender: DropTargetArea;
}
interface DropTargetAreaDragenterEvent extends DropTargetAreaEvent {
draggable?: JQuery;
}
interface DropTargetAreaDragleaveEvent extends DropTargetAreaEvent {
draggable?: JQuery;
}
interface DropTargetAreaDropEvent extends DropTargetAreaEvent {
draggable?: kendo.ui.Draggable;
dropTarget?: JQuery;
}
interface DraggableOptions {
axis?: string;
cursorOffset?: any;
distance?: number;
group?: string;
hint?: Function;
drag?(e: DraggableEvent): void;
dragcancel?(e: DraggableEvent): void;
dragend?(e: DraggableEvent): void;
dragstart?(e: DraggableEvent): void;
}
interface GridColumnEditorOptions {
field?: string;
format?: string;
model?: kendo.data.Model;
values?: any[];
}
interface GridColumn {
editor?(container: JQuery, options: GridColumnEditorOptions): void;
}
}
declare module kendo.mobile {
function init(selector: string): void;
function init(element: JQuery): void;
function init(element: Element): void;
class Application extends Observable {
constructor(element?: any, options?: ApplicationOptions);
init(element?: any, options?: ApplicationOptions): void;
options: ApplicationOptions;
hideLoading(): void;
navigate(url: string, transition?: string): void;
scroller(): kendo.mobile.ui.Scroller;
showLoading(): void;
view(): kendo.mobile.ui.View;
}
interface ApplicationOptions {
hideAddressBar?: bool;
updateDocumentTitle?: bool;
initial?: string;
layout?: string;
loading?: string;
platform?: string;
serverNavigation?: bool;
transition?: string;
}
interface ApplicationEvent {
sender: Application;
}
}
declare module kendo.mobile.ui {
class Widget extends kendo.ui.Widget {
}
interface TouchAxis {
location?: number;
startLocation?: number;
client?: number;
delta?: number;
velocity?: number;
}
interface TouchEventOptions {
target?: JQuery;
x?: TouchAxis;
y?: TouchAxis;
}
interface Point {
x?: number;
y?: number;
}
}
declare module kendo.dataviz.ui {
function registerTheme(name: string, options: any);
function plugin(widget: new (element: Element, options: Object) => kendo.ui.Widget);
}
declare module kendo.ui {
class AutoComplete extends kendo.ui.Widget {
static fn: AutoComplete;
static extend(proto: Object): AutoComplete;
element: JQuery;
wrapper: JQuery;
constructor(element: Element, options?: AutoCompleteOptions);
options: AutoCompleteOptions;
dataSource: kendo.data.DataSource;
close(): void;
dataItem(index?: number): any;
destroy(): void;
enable(enable: bool): void;
readonly(readonly: bool): void;
focus(): void;
refresh(): void;
search(word: string): void;
select(item: any): void;
setDataSource(dataSource: kendo.data.DataSource): void;
suggest(value: string): void;
value(): string;
value(value: string): void;
}
interface AutoCompleteAnimationClose {
effects?: string;
duration?: number;
}
interface AutoCompleteAnimationOpen {
effects?: string;
duration?: number;
}
interface AutoCompleteAnimation {
close?: AutoCompleteAnimationClose;
open?: AutoCompleteAnimationOpen;
}
interface AutoCompleteOptions {
name?: string;
animation?: AutoCompleteAnimation;
dataSource?: any;
dataTextField?: string;
delay?: number;
enable?: bool;
filter?: string;
height?: number;
highlightFirst?: bool;
ignoreCase?: bool;
minLength?: number;
placeholder?: string;
separator?: string;
suggest?: bool;
template?: any;
change?(e: AutoCompleteChangeEvent): void;
close?(e: AutoCompleteCloseEvent): void;
dataBound?(e: AutoCompleteDataBoundEvent): void;
open?(e: AutoCompleteOpenEvent): void;
select?(e: AutoCompleteSelectEvent): void;
}
interface AutoCompleteEvent {
sender: AutoComplete;
isDefaultPrevented(): bool;
preventDefault: Function;
}
interface AutoCompleteChangeEvent extends AutoCompleteEvent {
}
interface AutoCompleteCloseEvent extends AutoCompleteEvent {
}
interface AutoCompleteDataBoundEvent extends AutoCompleteEvent {
}
interface AutoCompleteOpenEvent extends AutoCompleteEvent {
}
interface AutoCompleteSelectEvent extends AutoCompleteEvent {
item?: JQuery;
}
class Calendar extends kendo.ui.Widget {
static fn: Calendar;
static extend(proto: Object): Calendar;
element: JQuery;
wrapper: JQuery;
constructor(element: Element, options?: CalendarOptions);
options: CalendarOptions;
destroy(): void;
max(): Date;
max(value: any): void;
min(): Date;
min(value: any): void;
navigate(value: Date, view: string): void;
navigateDown(value: Date): void;
navigateToFuture(): void;
navigateToPast(): void;
navigateUp(): void;
value(): Date;
value(value: any): void;
current(): Date;
view(): any;
}
interface CalendarMonth {
content?: string;
empty?: string;
}
interface CalendarOptions {
name?: string;
culture?: string;
dates?: any;
depth?: string;
footer?: string;
format?: string;
max?: Date;
min?: Date;
month?: CalendarMonth;
start?: string;
value?: Date;
change?(e: CalendarEvent): void;
navigate?(e: CalendarEvent): void;
}
interface CalendarEvent {
sender: Calendar;
isDefaultPrevented(): bool;
preventDefault: Function;
}
class ColorPalette extends kendo.ui.Widget {
static fn: ColorPalette;
static extend(proto: Object): ColorPalette;
element: JQuery;
wrapper: JQuery;
constructor(element: Element, options?: ColorPaletteOptions);
options: ColorPaletteOptions;
value(): string;
value(color: string): void;
color(): void;
enable(): void;
}
interface ColorPaletteTileSize {
width?: number;
height?: number;
}
interface ColorPaletteOptions {
name?: string;
palette?: any;
columns?: number;
tileSize?: ColorPaletteTileSize;
value?: string;
change?(e: ColorPaletteEvent): void;
}
interface ColorPaletteEvent {
sender: ColorPalette;
isDefaultPrevented(): bool;
preventDefault: Function;
}
class ColorPicker extends kendo.ui.Widget {
static fn: ColorPicker;
static extend(proto: Object): ColorPicker;
element: JQuery;
wrapper: JQuery;
constructor(element: Element, options?: ColorPickerOptions);
options: ColorPickerOptions;
close(): void;
open(): void;
toggle(): void;
value(): string;
value(color: string): void;
color(): void;
enable(color: string): void;
}
interface ColorPickerTileSize {
width?: number;
height?: number;
}
interface ColorPickerOptions {
name?: string;
buttons?: bool;
columns?: number;
tileSize?: ColorPickerTileSize;
messages?: any;
palette
最低0.47元/天 解锁文章
2418
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
