mirror of
https://github.com/zhigang1992/DefinitelyTyped.git
synced 2026-04-24 05:06:02 +08:00
269 lines
10 KiB
TypeScript
269 lines
10 KiB
TypeScript
// Type definitions for vuejs 1.0.21
|
|
// Project: https://github.com/vuejs/vue
|
|
// Definitions by: odangosan <https://github.com/odangosan>, kaorun343 <https://github.com/kaorun343>
|
|
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
|
|
|
|
interface Array<T> {
|
|
$remove(item: T): Array<T>;
|
|
$set(index: any, val: T): T;
|
|
}
|
|
|
|
declare namespace vuejs {
|
|
|
|
interface PropOption {
|
|
type?: { new (...args: any[]): any; } | { new (...args: any[]): any; }[];
|
|
required?: boolean;
|
|
default?: any;
|
|
twoWay?: boolean;
|
|
validator?(value: any): boolean;
|
|
coerce?(value: any): any;
|
|
}
|
|
|
|
interface ComputedOption {
|
|
get(): any;
|
|
set(value: any): void;
|
|
}
|
|
|
|
interface WatchOption {
|
|
handler(val: any, oldVal: any): void;
|
|
deep?: boolean;
|
|
immidiate?: boolean;
|
|
}
|
|
|
|
interface DirectiveOption {
|
|
bind?(): any;
|
|
update?(newVal?: any, oldVal?: any): any;
|
|
unbind?(): any;
|
|
params?: string[];
|
|
deep?: boolean;
|
|
twoWay?: boolean;
|
|
acceptStatement?: boolean;
|
|
terminal?: boolean;
|
|
priority?: number;
|
|
[key: string]: any;
|
|
}
|
|
|
|
interface Directive {
|
|
el: HTMLElement;
|
|
vm: Vue;
|
|
expression: string;
|
|
arg?: string;
|
|
name: string;
|
|
modifiers: { [key: string]: boolean };
|
|
descriptor: any;
|
|
params?: { [key: string]: any };
|
|
}
|
|
|
|
interface FilterOption {
|
|
read?: Function;
|
|
write?: Function;
|
|
}
|
|
|
|
interface TransitionOption {
|
|
css?: boolean;
|
|
animation?: string;
|
|
enterClass?: string;
|
|
leaveClass?: string;
|
|
beforeEnter?(el: HTMLElement): void;
|
|
enter?(el: HTMLElement, done?: () => void): void;
|
|
afterEnter?(el: HTMLElement): void;
|
|
enterCancelled?(el: HTMLElement): void;
|
|
beforeLeave?(el: HTMLElement): void;
|
|
leave?(el: HTMLElement, done?: () => void): void;
|
|
afterLeave?(el: HTMLElement): void;
|
|
leaveCancelled?(el: HTMLElement): void;
|
|
stagger?(index: number): number;
|
|
enterStagger?(index: number): number;
|
|
leaveStagger?(index: number): number;
|
|
[key: string]: any;
|
|
}
|
|
|
|
interface ComponentOption {
|
|
data?: { [key: string]: any } | Function;
|
|
props?: string[] | { [key: string]: (PropOption | { new (...args: any[]): any; } | { new (...args: any[]): any; }[]) };
|
|
computed?: { [key: string]: (Function | ComputedOption) };
|
|
methods?: { [key: string]: Function };
|
|
watch?: { [key: string]: ((val: any, oldVal: any) => void) | string | WatchOption };
|
|
el?: string | HTMLElement | (() => HTMLElement);
|
|
template?: string;
|
|
replace?: boolean;
|
|
init?(): void;
|
|
created?(): void;
|
|
beforeCompile?(): void;
|
|
compiled?(): void;
|
|
ready?(): void;
|
|
attached?(): void;
|
|
detached?(): void;
|
|
beforeDestroy?(): void;
|
|
destroyed?(): void;
|
|
activate?(): void;
|
|
directives?: { [key: string]: (DirectiveOption | Function) };
|
|
elementDirectives?: { [key: string]: (DirectiveOption | Function) };
|
|
filters?: { [key: string]: (Function | FilterOption) };
|
|
components?: { [key: string]: any };
|
|
transitions?: { [key: string]: TransitionOption };
|
|
partials?: { [key: string]: string };
|
|
parent?: Vue;
|
|
events?: { [key: string]: ((...args: any[]) => (boolean | void)) | string };
|
|
mixins?: Object[];
|
|
name?: string;
|
|
[key: string]: any;
|
|
}
|
|
|
|
interface Vue {
|
|
$data: any;
|
|
$el: HTMLElement;
|
|
$options: Object;
|
|
$parent: Vue;
|
|
$root: Vue;
|
|
$children: Vue[];
|
|
$refs: Object;
|
|
$els: Object;
|
|
|
|
// instance/api/data.js
|
|
$get(exp: string, asStatement?: boolean): any;
|
|
$set<T>(key: string | number, value: T): T;
|
|
$delete(key: string): void;
|
|
$eval(expression: string): string;
|
|
$interpolate(expression: string): string;
|
|
$log(keypath?: string): void;
|
|
$watch(expOrFn: string | Function, callback: ((newVal: any, oldVal?: any) => any) | string, options?: { deep?: boolean, immidiate?: boolean }): Function;
|
|
// instance/api/dom.js
|
|
$nextTick(callback: Function): void;
|
|
$appendTo(target: (HTMLElement | string), callback?: Function, withTransition?: boolean): this;
|
|
$prependTo(target: (HTMLElement | string), callback?: Function, withTransition?: boolean): this;
|
|
$before(target: (HTMLElement | string), callback?: Function, withTransition?: boolean): this;
|
|
$after(target: (HTMLElement | string), callback?: Function, withTransition?: boolean): this;
|
|
$remove(callback?: Function): this;
|
|
// instance/api/events.js
|
|
$on(event: string, callback: Function): this;
|
|
$once(event: string, callback: Function): this;
|
|
$off(event: string, callback?: Function): this;
|
|
$emit(event: string, ...args: any[]): this;
|
|
$broadcast(event: string, ...args: any[]): this;
|
|
$dispatch(event: string, ...args: any[]): this;
|
|
// instance/api/lifecycle.js
|
|
$mount(elementOrSelector?: (HTMLElement | string)): this;
|
|
$destroy(remove?: boolean): void;
|
|
$compile(el: Element | DocumentFragment, host?: Vue): Function;
|
|
|
|
_init(options?: ComponentOption): void;
|
|
}
|
|
|
|
interface VueConfig {
|
|
debug: boolean;
|
|
delimiters: [string, string];
|
|
unsafeDelimiters: [string, string];
|
|
silent: boolean;
|
|
async: boolean;
|
|
devtools: boolean;
|
|
}
|
|
|
|
interface VueUtil {
|
|
// util/lang.js
|
|
set(obj: Object, key: string, value: any): void;
|
|
del(obj: Object, key: string): void;
|
|
hasOwn(obj: Object, key: string): boolean;
|
|
isLiteral(exp: string): boolean;
|
|
isReserved(str: string): boolean;
|
|
_toString(value: any): string;
|
|
toNumber<T>(value: T): T | number;
|
|
toBoolean<T>(value: T): T | boolean;
|
|
stripQuotes(str: string): string;
|
|
camelize(str: string): string;
|
|
hyphenate(str: string): string;
|
|
classify(str: string): string;
|
|
bind(fn: Function, ctx: Object): Function;
|
|
toAarray<T>(list: ArrayLike<T>, start?: number): Array<T>;
|
|
extend<T, F>(to: T, from: F): (T & F);
|
|
isObject(obj: any): boolean;
|
|
isPlainObject(obj: any): boolean;
|
|
isArray: typeof Array.isArray;
|
|
def(obj: Object, key: string, value: any, enumerable?: boolean): void;
|
|
debounce(func: Function, wait: number): Function;
|
|
indexOf<T>(arr: Array<T>, obj: T): number;
|
|
cancellable(fn: Function): Function;
|
|
looseEqual(a: any, b: any): boolean;
|
|
// util/env.js
|
|
hasProto: boolean;
|
|
inBrowser: boolean;
|
|
isIE9: boolean;
|
|
isAndroid: boolean;
|
|
transitionProp: string;
|
|
transitionEndEvent: string;
|
|
animationProp: string;
|
|
animationEndEvent: string;
|
|
nextTick(cb: Function, ctx?: Object): void;
|
|
// util/dom.js
|
|
query(el: string | Element): Element;
|
|
inDoc(node: Node): boolean;
|
|
getAttr(node: Node, _attr: string): string;
|
|
getBindAttr(node: Node, name: string): string;
|
|
before(el: Element, target: Element): void;
|
|
after(el: Element, target: Element): void;
|
|
remove(el: Element): void;
|
|
prepend(el: Element, target: Element): void;
|
|
replace(target: Element, el: Element): void;
|
|
on(el: Element, event: string, cb: Function): void;
|
|
off(el: Element, event: string, cb: Function): void;
|
|
addClass(el: Element, cls: string): void;
|
|
removeClass(el: Element, cls: string): void;
|
|
extractContent(el: Element, asFragment: boolean): (HTMLDivElement | DocumentFragment);
|
|
trimNode(node: Node): void;
|
|
isTemplate(el: Element): boolean;
|
|
createAnchor(content: string, persist: boolean): (Comment | Text);
|
|
findRef(node: Element): string;
|
|
mapNodeRange(node: Node, end: Node, op: Function): void;
|
|
removeNodeRange(start: Node, end: Node, vm: any, frag: DocumentFragment, cb: Function): void;
|
|
// util/options.js
|
|
mergeOptions<P, C>(parent: P, child: C, vm?: any): (P & C);
|
|
resolveAsset(options: Object, type: string, id: string): (Object | Function);
|
|
assertAsset(val: any, type: string, id: string): void;
|
|
// util/component.js
|
|
commonTagRE: RegExp;
|
|
checkComponentAttr(el: Element, options?: Object): Object;
|
|
initProp(vm: Vue, prop: Object, value: any): void;
|
|
assertProp(prop: Object, value: any): boolean;
|
|
// util/debug.js
|
|
warn(msg: string, e?: Error): void;
|
|
// observer/index.js
|
|
defineReactive(obj: Object, key: string, val: any): void;
|
|
}
|
|
|
|
// instance/api/global.js
|
|
interface VueStatic {
|
|
new (options?: ComponentOption): Vue;
|
|
prototype: Vue;
|
|
util: VueUtil;
|
|
config: VueConfig;
|
|
set(object: Object, key: string, value: any): void;
|
|
delete(object: Object, key: string): void;
|
|
nextTick(callback: Function): any;
|
|
|
|
cid: number;
|
|
|
|
extend(options?: ComponentOption): VueStatic;
|
|
use(callback: Function | { install: Function, [key: string]: any }, option?: Object): VueStatic;
|
|
mixin(mixin: Object): void;
|
|
|
|
directive<T extends (Function | DirectiveOption)>(id: string, definition: T): T;
|
|
directive(id: string): any;
|
|
elementDirective<T extends (Function | DirectiveOption)>(id: string, definition: T): T;
|
|
elementDirective(id: string): any;
|
|
filter<T extends (Function | FilterOption)>(id: string, definition: T): T;
|
|
filter(id: string): any;
|
|
component(id: string, definition: ComponentOption): any;
|
|
component(id: string): any;
|
|
transition<T extends TransitionOption>(id: string, hooks: T): T;
|
|
transition(id: string): TransitionOption;
|
|
partial(id: string, partial: string): string;
|
|
partial(id: string): string;
|
|
}
|
|
}
|
|
|
|
declare var Vue: vuejs.VueStatic;
|
|
|
|
declare module "vue" {
|
|
export = Vue;
|
|
}
|