mirror of
https://github.com/gosticks/DefinitelyTyped.git
synced 2026-07-01 07:40:10 +00:00
Merge pull request #2130 from teppeis/esprima
Add definition for Esprima
This commit is contained in:
Basarat Ali Syed
@@ -63,6 +63,7 @@ All definitions files include a header with the author and editors, so at some p
|
||||
* [emissary](https://github.com/atom/emissary) (by [vvakame](https://github.com/vvakame))
|
||||
* [EpicEditor](http://epiceditor.com/) (by [Boris Yankov](https://github.com/borisyankov))
|
||||
* [ES6-Promises](https://github.com/jakearchibald/ES6-Promises) (by [François de Campredon](https://github.com/fdecampredon/))
|
||||
* [Esprima](http://esprima.org/) (by [Teppei Sato](https://github.com/teppeis))
|
||||
* [expect.js](https://github.com/LearnBoost/expect.js) (by [Teppei Sato](https://github.com/teppeis))
|
||||
* [expectations](https://github.com/spmason/expectations) (by [vvakame](https://github.com/vvakame))
|
||||
* [Express](http://expressjs.com/) (by [Boris Yankov](https://github.com/borisyankov))
|
||||
|
||||
163
esprima/esprima-tests.ts
Normal file
163
esprima/esprima-tests.ts
Normal file
@@ -0,0 +1,163 @@
|
||||
/// <reference path="esprima.d.ts" />
|
||||
|
||||
import esprima = require('esprima');
|
||||
import Syntax = esprima.Syntax;
|
||||
|
||||
var token: esprima.Token;
|
||||
var options: esprima.Options;
|
||||
var comment: Syntax.Comment;
|
||||
var program: Syntax.Program;
|
||||
var statement: Syntax.SomeStatement;
|
||||
var blockStatement: Syntax.BlockStatement;
|
||||
var expression: Syntax.SomeExpression;
|
||||
var property: Syntax.Property;
|
||||
var identifier: Syntax.Identifier;
|
||||
var literal: Syntax.Literal;
|
||||
var switchCase: Syntax.SwitchCase;
|
||||
var catchClause: Syntax.CatchClause;
|
||||
var variableDeclaratorOrExpression: Syntax.VariableDeclaratorOrExpression;
|
||||
var literalOrIdentifier: Syntax.LiteralOrIdentifier;
|
||||
var blockStatementOrExpression: Syntax.BlockStatementOrExpression;
|
||||
var identifierOrExpression: Syntax.IdentifierOrExpression;
|
||||
var any: any;
|
||||
var string: string;
|
||||
var boolean: boolean;
|
||||
var number: number;
|
||||
|
||||
// esprima
|
||||
string = esprima.version;
|
||||
program = esprima.parse('code');
|
||||
program = esprima.parse('code', {range: true});
|
||||
token = esprima.tokenize('code')[0];
|
||||
token = esprima.tokenize('code', {range: true})[0];
|
||||
|
||||
// Token
|
||||
string = token.type;
|
||||
string = token.value;
|
||||
|
||||
// Program
|
||||
string = program.type;
|
||||
statement = program.body[0];
|
||||
comment = program.comments[0]
|
||||
|
||||
// Location
|
||||
number = program.loc.start.line;
|
||||
number = program.loc.start.column;
|
||||
number = program.loc.end.line;
|
||||
number = program.loc.end.column;
|
||||
number = program.range[0];
|
||||
|
||||
// Comment
|
||||
string = comment.value;
|
||||
|
||||
// Statement
|
||||
// BlockStatement
|
||||
string = statement.type;
|
||||
statement = statement.body[0];
|
||||
comment = statement.leadingComments[0]
|
||||
comment = statement.trailingComments[0]
|
||||
|
||||
// ExpressionStatement
|
||||
expression = statement.expression;
|
||||
|
||||
// IfStatement
|
||||
expression = statement.test;
|
||||
statement = statement.consequent;
|
||||
statement = statement.alternate;
|
||||
|
||||
// LabeledStatement
|
||||
identifier = statement.label;
|
||||
statement = statement.body;
|
||||
|
||||
// WithStatement
|
||||
expression = statement.object;
|
||||
|
||||
// SwitchStatement
|
||||
expression = statement.discriminant;
|
||||
switchCase = statement.cases[0];
|
||||
boolean = statement.lexical;
|
||||
|
||||
// ReturnStatement
|
||||
expression = statement.argument;
|
||||
|
||||
// TryStatement
|
||||
blockStatement = statement.block;
|
||||
catchClause = statement.handler;
|
||||
catchClause = statement.guardedHandlers[0];
|
||||
blockStatement = statement.finalizer;
|
||||
|
||||
// ForStatement
|
||||
variableDeclaratorOrExpression = statement.init;
|
||||
expression = statement.update;
|
||||
|
||||
// ForInStatement
|
||||
variableDeclaratorOrExpression = statement.left;
|
||||
expression = statement.right;
|
||||
boolean = statement.each;
|
||||
|
||||
// Expression
|
||||
// ArrayExpression
|
||||
string = expression.type;
|
||||
expression = expression.elements[0];
|
||||
|
||||
// ObjectExpression
|
||||
property = expression.properties[0];
|
||||
string = property.type;
|
||||
literalOrIdentifier = property.key;
|
||||
expression = property.value;
|
||||
string = property.kind;
|
||||
|
||||
// FunctionExpression
|
||||
identifier = expression.id;
|
||||
identifier = expression.params[0];
|
||||
expression = expression.defaults[0];
|
||||
identifier = expression.rest;
|
||||
blockStatementOrExpression = expression.body;
|
||||
boolean = expression.generator;
|
||||
boolean = expression.expression;
|
||||
|
||||
// SequenceExpression
|
||||
expression = expression.expressions[0]
|
||||
|
||||
// UnaryExpression
|
||||
string = expression.operator;
|
||||
boolean = expression.prefix;
|
||||
|
||||
// BinaryExpression
|
||||
expression = expression.left;
|
||||
expression = expression.right;
|
||||
|
||||
// ConditionalExpression
|
||||
expression = expression.test;
|
||||
expression = expression.alternate;
|
||||
expression = expression.consequent;
|
||||
|
||||
// ConditionalExpression
|
||||
expression = expression.callee;
|
||||
expression = expression.arguments[0];
|
||||
|
||||
// MemberExpression
|
||||
expression = expression.object;
|
||||
identifierOrExpression = expression.property;
|
||||
boolean = expression.computed;
|
||||
|
||||
// Clauses
|
||||
// SwitchCase
|
||||
string = switchCase.type;
|
||||
expression = switchCase.test;
|
||||
statement = switchCase.consequent[0];
|
||||
|
||||
// CatchClause
|
||||
string = catchClause.type;
|
||||
identifier = catchClause.param;
|
||||
expression = catchClause.guard;
|
||||
blockStatement = catchClause.body;
|
||||
|
||||
// Misc
|
||||
// Identifier
|
||||
string = identifier.type;
|
||||
string = identifier.name;
|
||||
|
||||
// Literal
|
||||
string = literal.type;
|
||||
any = literal.value;
|
||||
276
esprima/esprima.d.ts
vendored
Normal file
276
esprima/esprima.d.ts
vendored
Normal file
@@ -0,0 +1,276 @@
|
||||
// Type definitions for Esprima v1.2.0
|
||||
// Project: http://esprima.org
|
||||
// Definitions by: teppeis <https://github.com/teppeis/>
|
||||
// Definitions: https://github.com/borisyankov/DefinitelyTyped
|
||||
|
||||
declare module esprima {
|
||||
var version: string;
|
||||
function parse(code: string, options?: Options): Syntax.Program;
|
||||
function tokenize(code: string, options?: Options): Array<Token>;
|
||||
|
||||
interface Token {
|
||||
type: string
|
||||
value: string
|
||||
}
|
||||
|
||||
interface Options {
|
||||
loc?: boolean
|
||||
range?: boolean
|
||||
raw?: boolean
|
||||
tokens?: boolean
|
||||
comment?: boolean
|
||||
attachComment?: boolean
|
||||
tolerant?: boolean
|
||||
source?: boolean
|
||||
}
|
||||
|
||||
module Syntax {
|
||||
// Node
|
||||
interface Node {
|
||||
type: string
|
||||
loc?: LineLocation
|
||||
range?: number[]
|
||||
leadingComments?: Comment[]
|
||||
trailingComments?: Comment[]
|
||||
}
|
||||
interface LineLocation {
|
||||
start: Position
|
||||
end: Position
|
||||
}
|
||||
interface Position {
|
||||
line: number
|
||||
column: number
|
||||
}
|
||||
|
||||
// Comment
|
||||
interface Comment extends Node {
|
||||
value: string
|
||||
}
|
||||
|
||||
// Program
|
||||
interface Program extends Node {
|
||||
body: SomeStatement[]
|
||||
comments?: Comment[]
|
||||
}
|
||||
|
||||
// Function
|
||||
interface Function extends Node {
|
||||
id: Identifier // | null
|
||||
params: Identifier[]
|
||||
defaults: SomeExpression[]
|
||||
rest: Identifier // | null
|
||||
body: BlockStatementOrExpression
|
||||
generator: boolean
|
||||
expression: boolean
|
||||
}
|
||||
interface BlockStatementOrExpression extends Array<SomeStatement>, BlockStatement, SomeExpression {
|
||||
body: BlockStatementOrExpression
|
||||
}
|
||||
|
||||
// Statement
|
||||
interface Statement extends Node {
|
||||
}
|
||||
interface EmptyStatement extends Statement {
|
||||
}
|
||||
interface BlockStatement extends Statement {
|
||||
body: SomeStatement[]
|
||||
}
|
||||
interface ExpressionStatement extends Statement {
|
||||
expression: SomeExpression
|
||||
}
|
||||
interface IfStatement extends Statement {
|
||||
test: SomeExpression
|
||||
consequent: SomeStatement
|
||||
alternate: SomeStatement
|
||||
}
|
||||
interface LabeledStatement extends Statement {
|
||||
label: Identifier
|
||||
body: SomeStatement
|
||||
}
|
||||
interface BreakStatement extends Statement {
|
||||
label: Identifier // | null
|
||||
}
|
||||
interface ContinueStatement extends Statement {
|
||||
label: Identifier // | null
|
||||
}
|
||||
interface WithStatement extends Statement {
|
||||
object: SomeExpression
|
||||
body: SomeStatement
|
||||
}
|
||||
interface SwitchStatement extends Statement {
|
||||
discriminant: SomeExpression
|
||||
cases: SwitchCase[]
|
||||
lexical: boolean
|
||||
}
|
||||
interface ReturnStatement extends Statement {
|
||||
argument: SomeExpression // | null
|
||||
}
|
||||
interface ThrowStatement extends Statement {
|
||||
argument: SomeExpression
|
||||
}
|
||||
interface TryStatement extends Statement {
|
||||
block: BlockStatement
|
||||
handler: CatchClause // | null
|
||||
guardedHandlers: CatchClause[]
|
||||
finalizer: BlockStatement // | null
|
||||
}
|
||||
interface WhileStatement extends Statement {
|
||||
test: SomeExpression
|
||||
body: SomeStatement
|
||||
}
|
||||
interface DoWhileStatement extends Statement {
|
||||
body: SomeStatement
|
||||
test: SomeExpression
|
||||
}
|
||||
interface ForStatement extends Statement {
|
||||
init: VariableDeclaratorOrExpression // | null
|
||||
test: SomeExpression // | null
|
||||
update: SomeExpression // | null
|
||||
body: SomeStatement
|
||||
}
|
||||
interface ForInStatement extends Statement {
|
||||
left: VariableDeclaratorOrExpression
|
||||
right: SomeExpression
|
||||
body: SomeStatement
|
||||
each: boolean
|
||||
}
|
||||
interface VariableDeclaratorOrExpression extends VariableDeclarator, SomeExpression {
|
||||
}
|
||||
interface DebuggerStatement extends Statement {
|
||||
}
|
||||
interface SomeStatement extends
|
||||
EmptyStatement, ExpressionStatement, BlockStatement, IfStatement,
|
||||
LabeledStatement, BreakStatement, ContinueStatement, WithStatement,
|
||||
SwitchStatement, ReturnStatement, ThrowStatement, TryStatement,
|
||||
WhileStatement, DoWhileStatement, ForStatement, ForInStatement, DebuggerStatement {
|
||||
body: SomeStatementOrList
|
||||
}
|
||||
interface SomeStatementOrList extends Array<SomeStatement>, SomeStatement {
|
||||
}
|
||||
|
||||
// Declration
|
||||
interface Declration extends Statement {
|
||||
}
|
||||
interface FunctionDeclration extends Declration {
|
||||
id: Identifier
|
||||
params: Identifier[] // Pattern
|
||||
defaults: SomeExpression[]
|
||||
rest: Identifier
|
||||
body: BlockStatementOrExpression
|
||||
generator: boolean
|
||||
expression: boolean
|
||||
}
|
||||
interface VariableDeclaration extends Declration {
|
||||
declarations: VariableDeclarator[]
|
||||
kind: string // "var" | "let" | "const"
|
||||
}
|
||||
interface VariableDeclarator extends Node {
|
||||
id: Identifier // Pattern
|
||||
init: SomeExpression
|
||||
}
|
||||
|
||||
// Expression
|
||||
interface Expression extends Node { // | Pattern
|
||||
}
|
||||
interface SomeExpression extends
|
||||
ThisExpression, ArrayExpression, ObjectExpression, FunctionExpression,
|
||||
ArrowFunctionExpression, SequenceExpression, UnaryExpression, BinaryExpression,
|
||||
AssignmentExpression, UpdateExpression, LogicalExpression, ConditionalExpression,
|
||||
NewExpression, CallExpression, MemberExpression {
|
||||
}
|
||||
interface ThisExpression extends Expression {
|
||||
}
|
||||
interface ArrayExpression extends Expression {
|
||||
elements: SomeExpression[] // [ Expression | null ]
|
||||
}
|
||||
interface ObjectExpression extends Expression {
|
||||
properties: Property[]
|
||||
}
|
||||
interface Property extends Node {
|
||||
key: LiteralOrIdentifier // Literal | Identifier
|
||||
value: SomeExpression
|
||||
kind: string // "init" | "get" | "set"
|
||||
}
|
||||
interface LiteralOrIdentifier extends Literal, Identifier {
|
||||
}
|
||||
interface FunctionExpression extends Function, Expression {
|
||||
}
|
||||
interface ArrowFunctionExpression extends Function, Expression {
|
||||
}
|
||||
interface SequenceExpression extends Expression {
|
||||
expressions: SomeExpression[]
|
||||
}
|
||||
interface UnaryExpression extends Expression {
|
||||
operator: string // UnaryOperator
|
||||
prefix: boolean
|
||||
argument: SomeExpression
|
||||
}
|
||||
interface BinaryExpression extends Expression {
|
||||
operator: string // BinaryOperator
|
||||
left: SomeExpression
|
||||
right: SomeExpression
|
||||
}
|
||||
interface AssignmentExpression extends Expression {
|
||||
operator: string // AssignmentOperator
|
||||
left: SomeExpression
|
||||
right: SomeExpression
|
||||
}
|
||||
interface UpdateExpression extends Expression {
|
||||
operator: string // UpdateOperator
|
||||
argument: SomeExpression
|
||||
prefix: boolean
|
||||
}
|
||||
interface LogicalExpression extends Expression {
|
||||
operator: string // LogicalOperator
|
||||
left: SomeExpression
|
||||
right: SomeExpression
|
||||
}
|
||||
interface ConditionalExpression extends Expression {
|
||||
test: SomeExpression
|
||||
alternate: SomeExpression
|
||||
consequent: SomeExpression
|
||||
}
|
||||
interface NewExpression extends Expression {
|
||||
callee: SomeExpression
|
||||
arguments: SomeExpression[]
|
||||
}
|
||||
interface CallExpression extends Expression {
|
||||
callee: SomeExpression
|
||||
arguments: SomeExpression[]
|
||||
}
|
||||
interface MemberExpression extends Expression {
|
||||
object: SomeExpression
|
||||
property: IdentifierOrExpression // Identifier | Expression
|
||||
computed: boolean
|
||||
}
|
||||
interface IdentifierOrExpression extends Identifier, SomeExpression {
|
||||
}
|
||||
|
||||
// Pattern
|
||||
// interface Pattern extends Node {
|
||||
// }
|
||||
|
||||
// Clauses
|
||||
interface SwitchCase extends Node {
|
||||
test: SomeExpression
|
||||
consequent: SomeStatement[]
|
||||
}
|
||||
interface CatchClause extends Node {
|
||||
param: Identifier // Pattern
|
||||
guard: SomeExpression
|
||||
body: BlockStatement
|
||||
}
|
||||
|
||||
// Misc
|
||||
interface Identifier extends Node, Expression { // | Pattern
|
||||
name: string
|
||||
}
|
||||
interface Literal extends Node, Expression {
|
||||
value: any // string | boolean | null | number | RegExp
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
declare module "esprima" {
|
||||
export = esprima
|
||||
}
|
||||
Reference in New Issue
Block a user